Merge pull request #202 from orange-cpp/feature/gradient

Feature/gradient

VERSION

@@ -1 +1 @@
-5.3.0
+5.4.0

examples/example_dx11_hook/dllmain.cpp

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

examples/example_dx12_hook/dllmain.cpp

@@ -16,7 +16,10 @@ 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;
@@ -28,9 +31,188 @@ namespace
     ID3D12DescriptorHeap* g_rtv_heap = nullptr;
     ID3D12DescriptorHeap* g_srv_heap = nullptr;
     ID3D12GraphicsCommandList* g_command_list = nullptr;
-    ID3D12CommandAllocator* g_command_allocator = nullptr;
+    ID3D12Fence* g_fence = nullptr;
+    HANDLE g_fence_event = nullptr;
+    UINT64 g_fence_value = 0;
     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;
@@ -53,37 +235,15 @@ 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 (FAILED(g_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
+        if (!create_render_targets(swap_chain))
-                                                    IID_PPV_ARGS(&g_command_allocator))))
             return;
 
-        g_frames.resize(buffer_count);
+        if (!create_command_objects())
-        const UINT rtv_size = g_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+            return;
-        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();
@@ -114,27 +274,65 @@ 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;
+        {
+            const D3D12_COMMAND_QUEUE_DESC desc = queue->GetDesc();
+            if (desc.Type == D3D12_COMMAND_LIST_TYPE_DIRECT)
+                g_command_queue = queue;
+        }
     }
 
-    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
+    bool ensure_initialized(IDXGISwapChain* swap_chain)
     {
-        if (!g_initialized)
+        if (g_initialized)
-        {
+            return true;
-            if (!g_init_attempted && g_command_queue)
-                init(swap_chain);
-            return;
-        }
 
-        if (!g_command_queue)
+        if (!g_init_attempted && g_command_queue)
-            return;
+            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;
+            return false;
 
         ImGui_ImplDX12_NewFrame();
         ImGui_ImplWin32_NewFrame();
@@ -142,67 +340,97 @@ namespace
         ImGui::GetIO().MouseDrawCursor = true;
         ImGui::ShowDemoWindow();
         ImGui::EndFrame();
+        return true;
+    }
 
+    frame_context* current_frame_context()
+    {
         const UINT buf_idx = g_swap_chain->GetCurrentBackBufferIndex();
-        auto& fc = g_frames[buf_idx];
+        if (buf_idx >= g_frames.size())
+            return nullptr;
 
-        g_command_allocator->Reset();
+        return &g_frames[buf_idx];
-        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 = D3D12_RESOURCE_STATE_PRESENT;
+        barrier.Transition.StateBefore = before;
-        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
+        barrier.Transition.StateAfter = after;
         g_command_list->ResourceBarrier(1, &barrier);
+    }
+
+    void record_overlay_commands(frame_context& fc)
+    {
+        transition_render_target(fc, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET);
         g_command_list->OMSetRenderTargets(1, &fc.rtv_handle, FALSE, nullptr);
         g_command_list->SetDescriptorHeaps(1, &g_srv_heap);
 
         ImGui::Render();
         ImGui_ImplDX12_RenderDrawData(ImGui::GetDrawData(), g_command_list);
 
-        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
+        transition_render_target(fc, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT);
-        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
+    }
-        g_command_list->ResourceBarrier(1, &barrier);
+
-        g_command_list->Close();
+    bool submit_overlay_commands(frame_context& fc)
+    {
+        if (FAILED(g_command_list->Close()))
+            return false;
 
         ID3D12CommandList* cmd_lists[] = {g_command_list};
         g_command_queue->ExecuteCommandLists(1, cmd_lists);
+        return signal_frame(fc);
+    }
+
+    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
+    {
+        if (!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()
     {
-        for (auto& fc : g_frames)
+        wait_for_gpu();
-        {
+        release_command_objects();
-            if (fc.render_target)
+        release_frame_contexts();
-            {
+        release_sync_objects();
-                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();
@@ -221,20 +449,20 @@ BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
     if (reason == DLL_PROCESS_ATTACH)
     {
         DisableThreadLibraryCalls(h_instance);
-        CreateThread(
+        std::thread(
-                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;
-                },
+                })
-                nullptr, 0, nullptr);
+                .detach();
     }
     else if (reason == DLL_PROCESS_DETACH)
     {

examples/example_dx9_hook/dllmain.cpp

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

examples/example_hud/gui/main_window.cpp

@@ -4,6 +4,7 @@
 #include "main_window.hpp"
 #include "omath/hud/renderer_realizations/imgui_renderer.hpp"
 #include <GLFW/glfw3.h>
+#include <cmath>
 #include <imgui.h>
 #include <imgui_impl_glfw.h>
 #include <imgui_impl_opengl3.h>
@@ -65,6 +66,19 @@ namespace imgui_desktop::gui
         ImGui::Begin("Controls", &m_opened,
                      ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
         ImGui::PushItemWidth(160.f);
+        const auto draw_glow_controls = [](const char* label, GlowSettings& settings)
+        {
+            ImGui::PushID(label);
+            ImGui::TextUnformatted(label);
+            ImGui::Checkbox("Glow", &settings.enabled);
+            if (settings.enabled)
+            {
+                ImGui::ColorEdit4("Color", reinterpret_cast<float*>(&settings.color), ImGuiColorEditFlags_NoInputs);
+                ImGui::InputFloat("Radius", &settings.radius);
+                ImGui::InputFloat("Intensity", &settings.intensity);
+            }
+            ImGui::PopID();
+        };
 
         if (ImGui::CollapsingHeader("Entity", ImGuiTreeNodeFlags_DefaultOpen))
         {
@@ -72,6 +86,12 @@ namespace imgui_desktop::gui
             ImGui::SliderFloat("Top Y", &m_entity_top_y, 20.f, m_entity_bottom_y - 20.f);
             ImGui::SliderFloat("Bottom Y", &m_entity_bottom_y, m_entity_top_y + 20.f, vp->Size.y - 20.f);
             ImGui::SliderFloat("Aspect", &m_entity_aspect, 1.f, 10.f);
+            draw_glow_controls("Canvas light", m_canvas_glow);
+            if (m_canvas_glow.enabled)
+            {
+                ImGui::InputInt("Blur layers##canvas", &m_canvas_glow_layers);
+                ImGui::InputFloat("Rounding##canvas", &m_canvas_glow_rounding);
+            }
         }
 
         if (ImGui::CollapsingHeader("Box", ImGuiTreeNodeFlags_DefaultOpen))
@@ -83,9 +103,20 @@ namespace imgui_desktop::gui
             ImGui::Checkbox("Dashed", &m_show_dashed_box);
             ImGui::ColorEdit4("Color##box", reinterpret_cast<float*>(&m_box_color), ImGuiColorEditFlags_NoInputs);
             ImGui::ColorEdit4("Fill##box", reinterpret_cast<float*>(&m_box_fill), ImGuiColorEditFlags_NoInputs);
+            ImGui::Checkbox("Gradient fill", &m_gradient_box_fill);
+            ImGui::Checkbox("Animate gradients", &m_animate_gradients);
+            if (m_gradient_box_fill)
+            {
+                ImGui::ColorEdit4("Gradient top##box", reinterpret_cast<float*>(&m_box_gradient_top),
+                                  ImGuiColorEditFlags_NoInputs);
+                ImGui::ColorEdit4("Gradient bottom##box", reinterpret_cast<float*>(&m_box_gradient_bottom),
+                                  ImGuiColorEditFlags_NoInputs);
+            }
             ImGui::ColorEdit4("Outline##box", reinterpret_cast<float*>(&m_box_outline), ImGuiColorEditFlags_NoInputs);
             ImGui::SliderFloat("Thickness", &m_box_thickness, 0.5f, 5.f);
             ImGui::SliderFloat("Corner ratio", &m_corner_ratio, 0.05f, 0.5f);
+            draw_glow_controls("Box glow", m_box_glow);
+            draw_glow_controls("Cornered box glow", m_cornered_box_glow);
             ImGui::Separator();
             ImGui::ColorEdit4("Dash color", reinterpret_cast<float*>(&m_dash_color), ImGuiColorEditFlags_NoInputs);
             ImGui::SliderFloat("Dash length", &m_dash_len, 2.f, 30.f);
@@ -99,6 +130,7 @@ namespace imgui_desktop::gui
             ImGui::ColorEdit4("BG##bar", reinterpret_cast<float*>(&m_bar_bg_color), ImGuiColorEditFlags_NoInputs);
             ImGui::ColorEdit4("Outline##bar", reinterpret_cast<float*>(&m_bar_outline_color),
                               ImGuiColorEditFlags_NoInputs);
+            ImGui::Checkbox("Gradient bars", &m_gradient_bars);
             ImGui::SliderFloat("Width##bar", &m_bar_width, 1.f, 20.f);
             ImGui::SliderFloat("Value##bar", &m_bar_value, 0.f, 1.f);
             ImGui::SliderFloat("Offset##bar", &m_bar_offset, 1.f, 20.f);
@@ -116,11 +148,20 @@ namespace imgui_desktop::gui
             ImGui::Checkbox("Bot dashed##bar", &m_show_bottom_dashed_bar);
             ImGui::SliderFloat("Dash len##bar", &m_bar_dash_len, 2.f, 20.f);
             ImGui::SliderFloat("Dash gap##bar", &m_bar_dash_gap, 1.f, 15.f);
+            draw_glow_controls("Bar glow", m_bar_glow);
         }
 
         if (ImGui::CollapsingHeader("Labels", ImGuiTreeNodeFlags_DefaultOpen))
         {
             ImGui::Checkbox("Outlined", &m_outlined);
+            ImGui::Checkbox("Gradient centered label", &m_gradient_label);
+            if (m_gradient_label)
+            {
+                ImGui::ColorEdit4("Gradient left##lbl", reinterpret_cast<float*>(&m_label_gradient_left),
+                                  ImGuiColorEditFlags_NoInputs);
+                ImGui::ColorEdit4("Gradient right##lbl", reinterpret_cast<float*>(&m_label_gradient_right),
+                                  ImGuiColorEditFlags_NoInputs);
+            }
             ImGui::SliderFloat("Offset##lbl", &m_label_offset, 0.f, 15.f);
             ImGui::Checkbox("Right##lbl", &m_show_right_labels);
             ImGui::SameLine();
@@ -131,6 +172,7 @@ namespace imgui_desktop::gui
             ImGui::Checkbox("Ctr top##lbl", &m_show_centered_top);
             ImGui::SameLine();
             ImGui::Checkbox("Ctr bot##lbl", &m_show_centered_bottom);
+            draw_glow_controls("Label glow", m_label_glow);
         }
 
         if (ImGui::CollapsingHeader("Skeleton"))
@@ -193,9 +235,82 @@ namespace imgui_desktop::gui
         using namespace omath::hud::widget;
         using omath::hud::when;
         const auto* vp = ImGui::GetMainViewport();
-        const Bar bar{m_bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width, m_bar_value, m_bar_offset};
         const DashedBar dbar{m_bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width,
                              m_bar_value, m_bar_dash_len,      m_bar_dash_gap, m_bar_offset};
+        const float entity_height = m_entity_bottom_y - m_entity_top_y;
+        const float entity_half_width = entity_height / m_entity_aspect;
+        const auto joint = [&](const float x, const float y)
+        {
+            return omath::Vector2<float>{m_entity_x + (x * 2.f - 1.f) * entity_half_width,
+                                         m_entity_top_y + y * entity_height};
+        };
+        const auto head = joint(0.5f, 0.1f);
+        const auto neck = joint(0.5f, 0.22f);
+        const auto torso = joint(0.5f, 0.5f);
+        const auto left_shoulder = joint(0.3f, 0.25f);
+        const auto right_shoulder = joint(0.7f, 0.25f);
+        const auto left_elbow = joint(0.18f, 0.42f);
+        const auto right_elbow = joint(0.82f, 0.42f);
+        const auto left_hand = joint(0.1f, 0.58f);
+        const auto right_hand = joint(0.9f, 0.58f);
+        const auto left_hip = joint(0.4f, 0.55f);
+        const auto right_hip = joint(0.6f, 0.55f);
+        const auto left_knee = joint(0.36f, 0.75f);
+        const auto right_knee = joint(0.64f, 0.75f);
+        const auto left_foot = joint(0.3f, 0.95f);
+        const auto right_foot = joint(0.7f, 0.95f);
+        const std::array skeleton_bones = {
+                Bone{head, neck},
+                Bone{neck, torso},
+                Bone{neck, left_shoulder},
+                Bone{left_shoulder, left_elbow},
+                Bone{left_elbow, left_hand},
+                Bone{neck, right_shoulder},
+                Bone{right_shoulder, right_elbow},
+                Bone{right_elbow, right_hand},
+                Bone{torso, left_hip},
+                Bone{left_hip, left_knee},
+                Bone{left_knee, left_foot},
+                Bone{torso, right_hip},
+                Bone{right_hip, right_knee},
+                Bone{right_knee, right_foot},
+        };
+        const auto animated_color = [&](const omath::Color& color, const float hue_offset)
+        {
+            if (!m_animate_gradients)
+                return color;
+
+            auto hsv = color.to_hsv();
+            hsv.hue = std::fmod(hsv.hue + static_cast<float>(ImGui::GetTime()) * 0.15f + hue_offset, 1.f);
+            const auto animated = omath::Color::from_hsv(hsv).value();
+            return omath::Color{animated.x, animated.y, animated.z, color.value().w};
+        };
+        const auto box_gradient_top = animated_color(m_box_gradient_top, 0.f);
+        const auto box_gradient_bottom = animated_color(m_box_gradient_bottom, 0.5f);
+        const auto red = omath::Color{1.f, 0.f, 0.f, 1.f};
+        const auto green = omath::Color{0.f, 1.f, 0.f, 1.f};
+        const auto make_glow = [](const GlowSettings& settings) -> std::optional<Glow>
+        {
+            if (!settings.enabled)
+                return std::nullopt;
+            return Glow{settings.color, settings.radius, settings.intensity};
+        };
+        const auto box_glow = make_glow(m_box_glow);
+        const auto cornered_box_glow = make_glow(m_cornered_box_glow);
+        const auto bar_glow = make_glow(m_bar_glow);
+        const auto label_glow = make_glow(m_label_glow);
+        const auto canvas_glow = make_glow(m_canvas_glow);
+        const BarPaint bar_color = m_gradient_bars ? BarPaint{BarGradient{red, green}} : BarPaint{m_bar_color};
+        const Bar bar{bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width, m_bar_value, m_bar_offset, bar_glow};
+        const Paint box_fill = m_gradient_box_fill
+                                       ? Paint{omath::hud::Gradient{box_gradient_top, box_gradient_top,
+                                                                    box_gradient_bottom, box_gradient_bottom}}
+                                       : Paint{m_box_fill};
+        const Paint centered_label_color =
+                m_gradient_label ? Paint{omath::hud::Gradient{m_label_gradient_left, m_label_gradient_right,
+                                                              m_label_gradient_right, m_label_gradient_left,
+                                                              m_animate_gradients}}
+                                 : Paint{omath::Color::from_rgba(255, 255, 255, 255)};
 
         auto outline_helper = [](const bool is_outline) -> Outlined
         {
@@ -204,10 +319,13 @@ namespace imgui_desktop::gui
         omath::hud::EntityOverlay({m_entity_x, m_entity_top_y}, {m_entity_x, m_entity_bottom_y}, m_entity_aspect,
                                   std::make_shared<omath::hud::ImguiHudRenderer>())
                 .contents(
+                        when(canvas_glow.has_value(), CanvasGlow{canvas_glow.value_or(Glow{m_canvas_glow.color}),
+                                                                 m_canvas_glow_layers, m_canvas_glow_rounding}),
                         // ── Boxes ────────────────────────────────────────────────────
-                        when(m_show_box, Box{m_box_color, m_box_fill, m_box_outline, m_box_thickness}),
+                        when(m_show_box, Box{m_box_color, box_fill, m_box_outline, m_box_thickness, box_glow}),
-                        when(m_show_cornered_box, CorneredBox{omath::Color::from_rgba(255, 0, 255, 255), m_box_fill,
+                        when(m_show_cornered_box,
-                                                              m_box_outline, m_corner_ratio, m_box_thickness}),
+                             CorneredBox{omath::Color::from_rgba(255, 0, 255, 255), m_box_fill, m_box_outline,
+                                         m_corner_ratio, m_box_thickness, cornered_box_glow}),
                         when(m_show_dashed_box, DashedBox{m_dash_color, m_dash_len, m_dash_gap, m_dash_thickness}),
                         RightSide{
                                 when(m_show_right_bar, bar),
@@ -254,14 +372,14 @@ namespace imgui_desktop::gui
                                 when(m_show_bottom_bar, bar),
                                 when(m_show_bottom_dashed_bar, dbar),
                                 when(m_show_centered_bottom,
-                                     Centered{Label{omath::Color::from_rgba(255, 255, 255, 255), m_label_offset,
+                                     Centered{Label{centered_label_color, m_label_offset, outline_helper(m_outlined),
-                                                    outline_helper(m_outlined), "PlayerName"}}),
+                                                    "Gradient PlayerName", label_glow}}),
                                 when(m_show_bottom_labels, Label{omath::Color::from_rgba(200, 200, 0, 255),
                                                                  m_label_offset, outline_helper(m_outlined), "42m"}),
                         },
                         when(m_show_aim, AimDot{{m_entity_x, m_entity_top_y + 40.f}, m_aim_color, m_aim_radius}),
                         when(m_show_scan, ScanMarker{m_scan_color, m_scan_outline, m_scan_outline_thickness}),
-                        when(m_show_skeleton, Skeleton{m_skel_color, m_skel_thickness}),
+                        when(m_show_skeleton, Skeleton{skeleton_bones, m_skel_color, m_skel_thickness}),
                         when(m_show_proj, ProjectileAim{{m_proj_pos_x, m_proj_pos_y},
                                                         m_proj_color,
                                                         m_proj_size,

examples/example_hud/gui/main_window.hpp

@@ -17,6 +17,14 @@ namespace imgui_desktop::gui
         void Run();
 
     private:
+        struct GlowSettings
+        {
+            omath::Color color{0.f, 0.7f, 1.f, 0.8f};
+            float radius = 4.f;
+            float intensity = 0.8f;
+            bool enabled = false;
+        };
+
         void draw_controls();
         void draw_overlay();
         void present();
@@ -30,8 +38,12 @@ namespace imgui_desktop::gui
         // Box
         omath::Color m_box_color{1.f, 1.f, 1.f, 1.f};
         omath::Color m_box_fill{0.f, 0.f, 0.f, 0.f};
+        omath::Color m_box_gradient_top{0.1f, 0.6f, 1.f, 0.55f};
+        omath::Color m_box_gradient_bottom{0.7f, 0.1f, 1.f, 0.15f};
         omath::Color m_box_outline{0.f, 0.f, 0.f, 0.f};
         float m_box_thickness = 1.f, m_corner_ratio = 0.2f;
+        bool m_gradient_box_fill = true;
+        bool m_animate_gradients = false;
         bool m_show_box = true, m_show_cornered_box = true, m_show_dashed_box = false;
 
         // Dashed box
@@ -43,19 +55,31 @@ namespace imgui_desktop::gui
         omath::Color m_bar_bg_color{0.f, 0.f, 0.f, 0.5f};
         omath::Color m_bar_outline_color{0.f, 0.f, 0.f, 1.f};
         float m_bar_width = 4.f, m_bar_value = 0.75f, m_bar_offset = 5.f;
-        bool m_show_right_bar = true,         m_show_left_bar = true;
+        bool m_gradient_bars = true;
-        bool m_show_top_bar = true,           m_show_bottom_bar = true;
+        bool m_show_right_bar = true, m_show_left_bar = true;
+        bool m_show_top_bar = true, m_show_bottom_bar = true;
         bool m_show_right_dashed_bar = false, m_show_left_dashed_bar = false;
-        bool m_show_top_dashed_bar = false,   m_show_bottom_dashed_bar = false;
+        bool m_show_top_dashed_bar = false, m_show_bottom_dashed_bar = false;
         float m_bar_dash_len = 6.f, m_bar_dash_gap = 4.f;
 
         // Labels
         float m_label_offset = 3.f;
+        omath::Color m_label_gradient_left{0.f, 0.8f, 1.f, 1.f};
+        omath::Color m_label_gradient_right{1.f, 0.2f, 0.7f, 1.f};
         bool m_outlined = true;
+        bool m_gradient_label = true;
         bool m_show_right_labels = true, m_show_left_labels = true;
-        bool m_show_top_labels = true,   m_show_bottom_labels = true;
+        bool m_show_top_labels = true, m_show_bottom_labels = true;
         bool m_show_centered_top = true, m_show_centered_bottom = true;
 
+        GlowSettings m_box_glow;
+        GlowSettings m_cornered_box_glow{{1.f, 0.f, 1.f, 0.8f}};
+        GlowSettings m_bar_glow{{1.f, 0.f, 0.f, 0.8f}};
+        GlowSettings m_label_glow;
+        GlowSettings m_canvas_glow{{1.f, 0.5f, 0.f, 0.8f}, 100.f};
+        int m_canvas_glow_layers = 64;
+        float m_canvas_glow_rounding = 40.f;
+
         // Skeleton
         omath::Color m_skel_color = omath::Color::from_rgba(255, 255, 255, 200);
         float m_skel_thickness = 1.f;

include/omath/3d_primitives/aabb.hpp

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

include/omath/algorithm/radar.hpp

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

include/omath/hud/canvas_box.hpp

@@ -9,6 +9,7 @@ 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")]]

include/omath/hud/entity_overlay.hpp

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

include/omath/hud/entity_overlay_widgets.hpp

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

include/omath/hud/gradient.hpp

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

include/omath/hud/hud_renderer_interface.hpp

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

include/omath/hud/renderer_realizations/imgui_renderer.hpp

@@ -13,10 +13,15 @@ namespace omath::hud
         ~ImguiHudRenderer() override;
         void add_line(const Vector2<float>& line_start, const Vector2<float>& line_end, const Color& color,
                       float thickness) override;
-        void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color, float thickness) override;
+        void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color,
+                          float thickness) override;
+        void add_polyline_clipped(const std::span<const Vector2<float>>& vertexes, const Vector2<float>& clip_min,
+                                  const Vector2<float>& clip_max, const Color& color, float thickness) override;
         void add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color) override;
         void add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) override;
         void add_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) override;
+        void add_gradient_rectangle(const Vector2<float>& min, const Vector2<float>& max,
+                                    const Gradient& gradient) override;
         void add_circle(const Vector2<float>& center, float radius, const Color& color, float thickness,
                         int segments = 0) override;
         void add_filled_circle(const Vector2<float>& center, float radius, const Color& color,
@@ -26,6 +31,8 @@ namespace omath::hud
         void add_image(const std::any& texture_id, const Vector2<float>& min, const Vector2<float>& max,
                        const Color& tint = Color{1.f, 1.f, 1.f, 1.f}) override;
         void add_text(const Vector2<float>& position, const Color& color, const std::string_view& text) override;
+        void add_gradient_text(const Vector2<float>& position, const Gradient& gradient,
+                               const std::string_view& text) override;
         [[nodiscard]]
         Vector2<float> calc_text_size(const std::string_view& text) override;
     };

include/omath/linear_algebra/mat.hpp

@@ -873,7 +873,7 @@ namespace omath
 } // namespace omath
 
 template<size_t Rows, size_t Columns, class Type, omath::MatStoreType StoreType>
-struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> final // NOLINT(*-dcl58-cpp)
 {
     using MatType = omath::Mat<Rows, Columns, Type, StoreType>;
     [[nodiscard("You must use parse iterator")]]

include/omath/linear_algebra/vector2.hpp

@@ -266,7 +266,7 @@ namespace omath
 } // namespace omath
 
 template<class Type>
-struct std::hash<omath::Vector2<Type>> // NOLINT(*-dcl58-cpp)
+struct std::hash<omath::Vector2<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use hash value")]]
     std::size_t operator()(const omath::Vector2<Type>& vec) const noexcept
@@ -282,7 +282,7 @@ struct std::hash<omath::Vector2<Type>> // NOLINT(*-dcl58-cpp)
 };
 
 template<class Type>
-struct std::formatter<omath::Vector2<Type>> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Vector2<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use parse iterator")]]
     static constexpr auto parse(std::format_parse_context& ctx) noexcept

include/omath/linear_algebra/vector3.hpp

@@ -319,7 +319,7 @@ namespace omath
 } // namespace omath
 
 template<class Type>
-struct std::hash<omath::Vector3<Type>> // NOLINT(*-dcl58-cpp)
+struct std::hash<omath::Vector3<Type>> final // NOLINT(*-dcl58-cpp)
 {
     // NOTE: Cannot be constexpr because of MSVC
     [[nodiscard("You must use hash value")]]
@@ -337,7 +337,7 @@ struct std::hash<omath::Vector3<Type>> // NOLINT(*-dcl58-cpp)
 };
 
 template<class Type>
-struct std::formatter<omath::Vector3<Type>> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Vector3<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use parse iterator")]]
     static constexpr auto parse(std::format_parse_context& ctx) noexcept

include/omath/linear_algebra/vector4.hpp

@@ -226,7 +226,7 @@ namespace omath
 } // namespace omath
 
 template<class Type>
-struct std::hash<omath::Vector4<Type>> // NOLINT(*-dcl58-cpp)
+struct std::hash<omath::Vector4<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use hash value")]]
     std::size_t operator()(const omath::Vector4<Type>& vec) const noexcept
@@ -242,7 +242,7 @@ struct std::hash<omath::Vector4<Type>> // NOLINT(*-dcl58-cpp)
     }
 };
 template<class Type>
-struct std::formatter<omath::Vector4<Type>> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Vector4<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use parse iterator")]]
     static constexpr auto parse(std::format_parse_context& ctx) noexcept

include/omath/pathfinding/a_star.hpp

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

include/omath/projection/camera.hpp

@@ -466,6 +466,23 @@ 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>
         world_to_view_port(const Vector3<NumericType>& world_position,
                            const ViewPortClipping& clipping = ViewPortClipping::AUTO) const noexcept

include/omath/trigonometry/angle.hpp

@@ -125,7 +125,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Angle operator+(const Angle& other) noexcept
+        constexpr Angle operator+(const Angle& other) const noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
                 return Angle{angles::wrap_angle(m_angle + other.m_angle, min, max)};
@@ -140,7 +140,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Angle operator-(const Angle& other) noexcept
+        constexpr Angle operator-(const Angle& other) const noexcept
         {
             return operator+(-other);
         }
@@ -154,10 +154,11 @@ namespace omath
 } // namespace omath
 
 template<class T, T MinV, T MaxV, omath::AngleFlags F>
-struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> final // NOLINT(*-dcl58-cpp)
 {
     using AngleT = omath::Angle<T, MinV, MaxV, F>;
 
+    [[nodiscard]]
     static constexpr auto parse(std::format_parse_context& ctx)
     {
         return ctx.begin();
@@ -174,10 +175,11 @@ struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> // NOLINT(*-dcl58-cp
 
 // wchar_t formatter
 template<class T, T MinV, T MaxV, omath::AngleFlags F>
-struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> final // NOLINT(*-dcl58-cpp)
 {
     using AngleT = omath::Angle<T, MinV, MaxV, F>;
 
+    [[nodiscard]]
     static constexpr auto parse(std::wformat_parse_context& ctx)
     {
         return ctx.begin();
@@ -194,10 +196,11 @@ struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> // NOLINT(*-dcl58
 
 // wchar_t formatter
 template<class T, T MinV, T MaxV, omath::AngleFlags F>
-struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char8_t> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char8_t> final // NOLINT(*-dcl58-cpp)
 {
     using AngleT = omath::Angle<T, MinV, MaxV, F>;
 
+    [[nodiscard]]
     static constexpr auto parse(std::wformat_parse_context& ctx)
     {
         return ctx.begin();

source/hud/entity_overlay.cpp

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

source/hud/renderer_realizations/imgui_renderer.cpp

@@ -4,7 +4,9 @@
 #include "omath/hud/renderer_realizations/imgui_renderer.hpp"
 
 #ifdef OMATH_IMGUI_INTEGRATION
+#include <cmath>
 #include <imgui.h>
+#include <imgui_internal.h>
 
 namespace omath::hud
 {
@@ -25,10 +27,21 @@ namespace omath::hud
                                                     ImDrawFlags_Closed, thickness);
     }
 
+    void ImguiHudRenderer::add_polyline_clipped(const std::span<const Vector2<float>>& vertexes,
+                                                const Vector2<float>& clip_min, const Vector2<float>& clip_max,
+                                                const Color& color, const float thickness)
+    {
+        auto* draw_list = ImGui::GetBackgroundDrawList();
+        draw_list->PushClipRect(clip_min.to_im_vec2(), clip_max.to_im_vec2(), true);
+        draw_list->AddPolyline(reinterpret_cast<const ImVec2*>(vertexes.data()), static_cast<int>(vertexes.size()),
+                               color.to_im_color(), ImDrawFlags_Closed, thickness);
+        draw_list->PopClipRect();
+    }
+
     void ImguiHudRenderer::add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color)
     {
         ImGui::GetBackgroundDrawList()->AddConvexPolyFilled(reinterpret_cast<const ImVec2*>(vertexes.data()),
-                                                    static_cast<int>(vertexes.size()), color.to_im_color());
+                                                            static_cast<int>(vertexes.size()), color.to_im_color());
     }
 
     void ImguiHudRenderer::add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color)
@@ -42,30 +55,39 @@ namespace omath::hud
         ImGui::GetBackgroundDrawList()->AddRectFilled(min.to_im_vec2(), max.to_im_vec2(), color.to_im_color());
     }
 
-    void ImguiHudRenderer::add_circle(const Vector2<float>& center, const float radius, const Color& color,
+    void ImguiHudRenderer::add_gradient_rectangle(const Vector2<float>& min, const Vector2<float>& max,
-                                       const float thickness, const int segments)
+                                                  const Gradient& gradient)
     {
-        ImGui::GetBackgroundDrawList()->AddCircle(center.to_im_vec2(), radius, color.to_im_color(), segments, thickness);
+        ImGui::GetBackgroundDrawList()->AddRectFilledMultiColor(
+                min.to_im_vec2(), max.to_im_vec2(), gradient.top_left.to_im_color(), gradient.top_right.to_im_color(),
+                gradient.bottom_right.to_im_color(), gradient.bottom_left.to_im_color());
+    }
+
+    void ImguiHudRenderer::add_circle(const Vector2<float>& center, const float radius, const Color& color,
+                                      const float thickness, const int segments)
+    {
+        ImGui::GetBackgroundDrawList()->AddCircle(center.to_im_vec2(), radius, color.to_im_color(), segments,
+                                                  thickness);
     }
 
     void ImguiHudRenderer::add_filled_circle(const Vector2<float>& center, const float radius, const Color& color,
-                                              const int segments)
+                                             const int segments)
     {
         ImGui::GetBackgroundDrawList()->AddCircleFilled(center.to_im_vec2(), radius, color.to_im_color(), segments);
     }
 
-    void ImguiHudRenderer::add_arc(const Vector2<float>& center, const float radius, const float a_min, const float a_max,
+    void ImguiHudRenderer::add_arc(const Vector2<float>& center, const float radius, const float a_min,
-                                    const Color& color, const float thickness, const int segments)
+                                   const float a_max, const Color& color, const float thickness, const int segments)
     {
         ImGui::GetBackgroundDrawList()->PathArcTo(center.to_im_vec2(), radius, a_min, a_max, segments);
         ImGui::GetBackgroundDrawList()->PathStroke(color.to_im_color(), ImDrawFlags_None, thickness);
     }
 
     void ImguiHudRenderer::add_image(const std::any& texture_id, const Vector2<float>& min, const Vector2<float>& max,
-                                      const Color& tint)
+                                     const Color& tint)
     {
         ImGui::GetBackgroundDrawList()->AddImage(std::any_cast<ImTextureID>(texture_id), min.to_im_vec2(),
-                                                  max.to_im_vec2(), {0, 0}, {1, 1}, tint.to_im_color());
+                                                 max.to_im_vec2(), {0, 0}, {1, 1}, tint.to_im_color());
     }
 
     void ImguiHudRenderer::add_text(const Vector2<float>& position, const Color& color, const std::string_view& text)
@@ -73,6 +95,58 @@ namespace omath::hud
         ImGui::GetBackgroundDrawList()->AddText(position.to_im_vec2(), color.to_im_color(), text.data(),
                                                 text.data() + text.size());
     }
+
+    void ImguiHudRenderer::add_gradient_text(const Vector2<float>& position, const Gradient& gradient,
+                                             const std::string_view& text)
+    {
+        auto* draw_list = ImGui::GetBackgroundDrawList();
+        if (gradient.animated)
+        {
+            const float animation_offset = static_cast<float>(ImGui::GetTime()) * gradient.animation_speed;
+            float cursor_x = position.x;
+            const char* glyph_start = text.data();
+            const char* const text_end = text.data() + text.size();
+            int glyph_index = 0;
+            while (glyph_start < text_end)
+            {
+                unsigned int codepoint;
+                const int glyph_size = ImTextCharFromUtf8(&codepoint, glyph_start, text_end);
+                if (glyph_size <= 0)
+                    break;
+                static_cast<void>(codepoint);
+
+                const char* const glyph_end = glyph_start + glyph_size;
+                const float blend =
+                        (std::sin(animation_offset + static_cast<float>(glyph_index) * gradient.animation_spread) + 1.f)
+                        * 0.5f;
+                const auto color = gradient.top_left.value() * (1.f - blend) + gradient.top_right.value() * blend;
+                draw_list->AddText({cursor_x, position.y}, Color{color}.to_im_color(), glyph_start, glyph_end);
+                cursor_x += ImGui::CalcTextSize(glyph_start, glyph_end).x;
+                glyph_start = glyph_end;
+                ++glyph_index;
+            }
+            return;
+        }
+
+        const int vertex_start = draw_list->VtxBuffer.Size;
+        draw_list->AddText(position.to_im_vec2(), IM_COL32_WHITE, text.data(), text.data() + text.size());
+
+        const auto size = calc_text_size(text);
+        const float width = std::max(size.x, 1.f);
+        const float height = std::max(size.y, 1.f);
+        for (int i = vertex_start; i < draw_list->VtxBuffer.Size; ++i)
+        {
+            auto& vertex = draw_list->VtxBuffer[i];
+            const float x = std::clamp((vertex.pos.x - position.x) / width, 0.f, 1.f);
+            const float y = std::clamp((vertex.pos.y - position.y) / height, 0.f, 1.f);
+            const auto top = gradient.top_left.value() * (1.f - x) + gradient.top_right.value() * x;
+            const auto bottom = gradient.bottom_left.value() * (1.f - x) + gradient.bottom_right.value() * x;
+            const auto color = top * (1.f - y) + bottom * y;
+            const auto alpha = static_cast<int>(((vertex.col >> IM_COL32_A_SHIFT) & 0xff) * color.w);
+            vertex.col = IM_COL32(static_cast<int>(color.x * 255.f), static_cast<int>(color.y * 255.f),
+                                  static_cast<int>(color.z * 255.f), alpha);
+        }
+    }
     [[nodiscard]]
     Vector2<float> ImguiHudRenderer::calc_text_size(const std::string_view& text)
     {

source/lua/lua_collision.cpp

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

tests/general/unit_test_aabb.cpp

@@ -4,7 +4,9 @@
 #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() ---
@@ -65,14 +67,12 @@ 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<UpAxis::Y>();
+    constexpr auto t = box.top();
     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<UpAxis::Y>();
+    constexpr auto t = box.top();
     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 AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
+    constexpr AABBZ box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    constexpr auto t = box.top<UpAxis::Z>();
+    constexpr auto t = box.top();
     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 AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
+    constexpr AABBZ box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
-    constexpr auto t = box.top<UpAxis::Z>();
+    constexpr auto t = box.top();
     EXPECT_FLOAT_EQ(t.x, 2.f);
     EXPECT_FLOAT_EQ(t.y, 7.f);
     EXPECT_FLOAT_EQ(t.z, 6.f);
@@ -108,7 +108,8 @@ TEST(AabbTests, TopZUpOffsetBox)
 TEST(AabbTests, TopDefaultIsYUp)
 {
     constexpr AABB box{{0.f, 0.f, 0.f}, {2.f, 4.f, 6.f}};
-    EXPECT_EQ(box.top(), box.top<UpAxis::Y>());
+    EXPECT_EQ(AABB::get_up_axis(), UpAxis::Y);
+    EXPECT_FLOAT_EQ(box.top().y, 4.f);
 }
 
 // --- bottom() ---
@@ -116,7 +117,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<UpAxis::Y>();
+    constexpr auto b = box.bottom();
     EXPECT_FLOAT_EQ(b.x, 0.f);
     EXPECT_FLOAT_EQ(b.y, -2.f);
     EXPECT_FLOAT_EQ(b.z, 0.f);
@@ -125,7 +126,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<UpAxis::Y>();
+    constexpr auto b = box.bottom();
     EXPECT_FLOAT_EQ(b.x, 2.f);
     EXPECT_FLOAT_EQ(b.y, 4.f);
     EXPECT_FLOAT_EQ(b.z, 4.f);
@@ -133,8 +134,8 @@ TEST(AabbTests, BottomYUpOffsetBox)
 
 TEST(AabbTests, BottomZUpSymmetricBox)
 {
-    constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
+    constexpr AABBZ box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    constexpr auto b = box.bottom<UpAxis::Z>();
+    constexpr auto b = box.bottom();
     EXPECT_FLOAT_EQ(b.x, 0.f);
     EXPECT_FLOAT_EQ(b.y, 0.f);
     EXPECT_FLOAT_EQ(b.z, -3.f);
@@ -142,8 +143,8 @@ TEST(AabbTests, BottomZUpSymmetricBox)
 
 TEST(AabbTests, BottomZUpOffsetBox)
 {
-    constexpr AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
+    constexpr AABBZ box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
-    constexpr auto b = box.bottom<UpAxis::Z>();
+    constexpr auto b = box.bottom();
     EXPECT_FLOAT_EQ(b.x, 2.f);
     EXPECT_FLOAT_EQ(b.y, 7.f);
     EXPECT_FLOAT_EQ(b.z, 2.f);
@@ -152,14 +153,33 @@ TEST(AabbTests, BottomZUpOffsetBox)
 TEST(AabbTests, BottomDefaultIsYUp)
 {
     constexpr AABB box{{0.f, 0.f, 0.f}, {2.f, 4.f, 6.f}};
-    EXPECT_EQ(box.bottom(), box.bottom<UpAxis::Y>());
+    EXPECT_EQ(AABB::get_up_axis(), UpAxis::Y);
+    EXPECT_FLOAT_EQ(box.bottom().y, 0.f);
 }
 
 TEST(AabbTests, TopAndBottomAreSymmetric)
 {
     constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    EXPECT_FLOAT_EQ(box.top<UpAxis::Y>().y, -box.bottom<UpAxis::Y>().y);
+    constexpr AABBZ z_up_box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    EXPECT_FLOAT_EQ(box.top<UpAxis::Z>().z, -box.bottom<UpAxis::Z>().z);
+    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));
 }
 
 // --- is_collide() ---

tests/general/unit_test_angle.cpp

@@ -183,7 +183,7 @@ TEST(UnitTestAngle, Formatter_PrintsDegreesWithSuffix)
 
 TEST(UnitTestAngle, BinaryPlus_ReturnsWrappedSum)
 {
-    Angle<> a = Deg::from_degrees(350.0f);
+    const 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,7 +191,7 @@ TEST(UnitTestAngle, BinaryPlus_ReturnsWrappedSum)
 
 TEST(UnitTestAngle, BinaryMinus_ReturnsWrappedDiff)
 {
-    Angle<> a = Deg::from_degrees(10.0f);
+    const 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);

tests/general/unit_test_entity_overlay.cpp

@@ -0,0 +1,33 @@
+//
+// 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_projection.cpp

@@ -1,6 +1,7 @@
 //
 // 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>
@@ -580,6 +581,48 @@ 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;
@@ -1241,8 +1284,9 @@ TEST(UnitTestProjection, TriangleFarToSideCulled)
 TEST(UnitTestProjection, TriangleStraddlingFrustumNotCulled)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.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 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}};
     EXPECT_FALSE(cam.is_culled_by_frustum(tri));

tests/general/unit_test_radar.cpp

@@ -0,0 +1,164 @@
+#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);
+}