diff --git a/examples/example_dx12_hook/dllmain.cpp b/examples/example_dx12_hook/dllmain.cpp index b6a56b61..1e7101ff 100644 --- a/examples/example_dx12_hook/dllmain.cpp +++ b/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 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, - IID_PPV_ARGS(&g_command_allocator)))) + if (!create_render_targets(swap_chain)) return; - g_frames.resize(buffer_count); - const UINT rtv_size = g_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV); - D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = g_rtv_heap->GetCPUDescriptorHandleForHeapStart(); - - 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 (!create_command_objects()) + return; - if (FAILED(g_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, g_command_allocator, nullptr, - IID_PPV_ARGS(&g_command_list)))) + if (!create_sync_objects()) 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_init_attempted && g_command_queue) - init(swap_chain); - return; - } + if (g_initialized) + return true; - if (!g_command_queue) - return; + if (!g_init_attempted && g_command_queue) + init(swap_chain); + + return false; + } + + bool ensure_render_targets(IDXGISwapChain* swap_chain) + { + if (!g_frames.empty() && g_rtv_heap) + return true; + + return create_render_targets(swap_chain); + } + + bool ensure_command_list() + { + if (g_command_list) + return true; + + return create_command_objects(); + } + + bool ensure_sync_ready() + { + if (g_fence) + return true; + + return create_sync_objects(); + } + + bool ensure_present_resources(IDXGISwapChain* swap_chain) + { + if (!ensure_initialized(swap_chain) || !g_command_queue) + return false; + + return ensure_render_targets(swap_chain) && ensure_command_list() && ensure_sync_ready(); + } + bool begin_imgui_frame() + { if (GetAsyncKeyState(VK_INSERT) & 1) show_menu = !show_menu; if (!show_menu) - return; + 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; + + return &g_frames[buf_idx]; + } - g_command_allocator->Reset(); - g_command_list->Reset(g_command_allocator, nullptr); + bool reset_overlay_command_list(frame_context& fc) + { + wait_for_frame(fc); + // Both resets depend on wait_for_frame(); otherwise DLSSG/Streamline can observe invalid GPU work. + if (FAILED(fc.command_allocator->Reset())) + return false; + + if (FAILED(g_command_list->Reset(fc.command_allocator, nullptr))) + return false; + + return true; + } + + void transition_render_target(frame_context& fc, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after) + { D3D12_RESOURCE_BARRIER barrier{}; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; barrier.Transition.pResource = fc.render_target; barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; - barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT; - barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET; + barrier.Transition.StateBefore = before; + 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; - barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT; - g_command_list->ResourceBarrier(1, &barrier); - g_command_list->Close(); + transition_render_target(fc, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT); + } + + bool submit_overlay_commands(frame_context& fc) + { + if (FAILED(g_command_list->Close())) + return false; 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) - { - if (fc.render_target) - { - fc.render_target->Release(); - fc.render_target = nullptr; - } - } - g_frames.clear(); - if (g_command_allocator) - { - g_command_allocator->Release(); - g_command_allocator = nullptr; - } - if (g_command_list) - { - g_command_list->Release(); - g_command_list = nullptr; - } + wait_for_gpu(); + release_command_objects(); + release_frame_contexts(); + release_sync_objects(); 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(); @@ -230,6 +458,7 @@ 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.set_on_execute_command_lists(on_execute_command_lists); std::ignore = mgr.hook_dx12(); return 0; diff --git a/include/omath/3d_primitives/aabb.hpp b/include/omath/3d_primitives/aabb.hpp index afd1872a..f2e2be25 100644 --- a/include/omath/3d_primitives/aabb.hpp +++ b/include/omath/3d_primitives/aabb.hpp @@ -4,17 +4,28 @@ #pragma once #include "omath/linear_algebra/vector3.hpp" +#include namespace omath::primitives { - enum class UpAxis { X, Y, Z }; + enum class UpAxis + { + X, + Y, + Z + }; - template + template struct Aabb final { Vector3 min; Vector3 max; + [[nodiscard]] + static consteval UpAxis get_up_axis() + { + return Up; + } [[nodiscard]] constexpr Vector3 center() const noexcept { @@ -27,7 +38,6 @@ namespace omath::primitives return (max - min) / static_cast(2); } - template [[nodiscard]] constexpr Vector3 top() const noexcept { @@ -42,7 +52,6 @@ namespace omath::primitives std::unreachable(); } - template [[nodiscard]] constexpr Vector3 bottom() const noexcept { @@ -57,11 +66,22 @@ namespace omath::primitives std::unreachable(); } + [[nodiscard]] + constexpr std::array, 8> vertices() const noexcept + { + return { + Vector3{min.x, min.y, min.z}, Vector3{max.x, min.y, min.z}, + Vector3{min.x, max.y, min.z}, Vector3{max.x, max.y, min.z}, + Vector3{min.x, min.y, max.z}, Vector3{max.x, min.y, max.z}, + Vector3{min.x, max.y, max.z}, Vector3{max.x, max.y, max.z}, + }; + } + [[nodiscard]] constexpr bool is_collide(const Aabb& other) const noexcept { - return min.x <= other.max.x && max.x >= other.min.x && - min.y <= other.max.y && max.y >= other.min.y &&min.z <= other.max.z && max.z >= other.min.z; + return min.x <= other.max.x && max.x >= other.min.x && min.y <= other.max.y && max.y >= other.min.y + && min.z <= other.max.z && max.z >= other.min.z; } }; } // namespace omath::primitives diff --git a/include/omath/hud/canvas_box.hpp b/include/omath/hud/canvas_box.hpp index fa06b92c..7bb8664a 100644 --- a/include/omath/hud/canvas_box.hpp +++ b/include/omath/hud/canvas_box.hpp @@ -9,6 +9,7 @@ namespace omath::hud class CanvasBox final { public: + CanvasBox() = default; CanvasBox(Vector2 top, Vector2 bottom, float ratio = 4.f); [[nodiscard("You have to use array")]] diff --git a/include/omath/hud/entity_overlay.hpp b/include/omath/hud/entity_overlay.hpp index 30c34f21..4e57cd55 100644 --- a/include/omath/hud/entity_overlay.hpp +++ b/include/omath/hud/entity_overlay.hpp @@ -5,11 +5,11 @@ #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 #include - namespace omath::hud { class EntityOverlay final @@ -57,13 +57,17 @@ namespace omath::hud float offset = 5.f); // ── Labels ─────────────────────────────────────────────────────── - EntityOverlay& add_right_label(const Color& color, float offset, widget::Outlined outlined, const std::string_view& text); + EntityOverlay& add_right_label(const Color& color, float offset, widget::Outlined outlined, + const std::string_view& text); - EntityOverlay& add_left_label(const Color& color, float offset, widget::Outlined outlined, const std::string_view& text); + EntityOverlay& add_left_label(const Color& color, float offset, widget::Outlined outlined, + const std::string_view& text); - EntityOverlay& add_top_label(const Color& color, float offset, widget::Outlined outlined, std::string_view text); + EntityOverlay& add_top_label(const Color& color, float offset, widget::Outlined outlined, + std::string_view text); - EntityOverlay& add_bottom_label(const Color& color, float offset, widget::Outlined outlined, std::string_view text); + EntityOverlay& add_bottom_label(const Color& color, float offset, widget::Outlined outlined, + std::string_view text); EntityOverlay& add_centered_top_label(const Color& color, float offset, widget::Outlined outlined, const std::string_view& text); @@ -72,24 +76,24 @@ namespace omath::hud const std::string_view& text); template - EntityOverlay& add_right_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string fmt, - Args&&... args) + EntityOverlay& add_right_label(const Color& color, const float offset, const widget::Outlined outlined, + std::format_string fmt, Args&&... args) { return add_right_label(color, offset, outlined, std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))}); } template - EntityOverlay& add_left_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string fmt, - Args&&... args) + EntityOverlay& add_left_label(const Color& color, const float offset, const widget::Outlined outlined, + std::format_string fmt, Args&&... args) { return add_left_label(color, offset, outlined, std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))}); } template - EntityOverlay& add_top_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string fmt, - Args&&... args) + EntityOverlay& add_top_label(const Color& color, const float offset, const widget::Outlined outlined, + std::format_string fmt, Args&&... args) { return add_top_label(color, offset, outlined, std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))}); @@ -112,8 +116,9 @@ namespace omath::hud } template - EntityOverlay& add_centered_bottom_label(const Color& color, const float offset, const widget::Outlined outlined, - std::format_string fmt, Args&&... args) + EntityOverlay& add_centered_bottom_label(const Color& color, const float offset, + const widget::Outlined outlined, std::format_string fmt, + Args&&... args) { return add_centered_bottom_label(color, offset, outlined, std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))}); @@ -164,6 +169,44 @@ namespace omath::hud return *this; } + template + static std::expected + from_aabb(const Camera& camera, const Aabb& aabb, const float aspect, + const std::shared_ptr& renderer) + { + Vector3 top; + Vector3 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(""); + + auto center = camera.world_to_screen_unclipped(aabb.center()); + if (!center) + return std::unexpected(""); + + return EntityOverlay{{center->x, top.y}, {center->x, bottom.y}, aspect, renderer}; + } + private: // optional dispatch — enables when() conditional widgets template diff --git a/source/lua/lua_collision.cpp b/source/lua/lua_collision.cpp index 00e55d34..35f8f5d7 100644 --- a/source/lua/lua_collision.cpp +++ b/source/lua/lua_collision.cpp @@ -119,11 +119,11 @@ namespace switch (axis) { case omath::primitives::UpAxis::X: - return aabb.top(); + return omath::primitives::Aabb{aabb.min, aabb.max}.top(); case omath::primitives::UpAxis::Y: - return aabb.top(); + return aabb.top(); case omath::primitives::UpAxis::Z: - return aabb.top(); + return omath::primitives::Aabb{aabb.min, aabb.max}.top(); } std::unreachable(); } @@ -133,11 +133,11 @@ namespace switch (axis) { case omath::primitives::UpAxis::X: - return aabb.bottom(); + return omath::primitives::Aabb{aabb.min, aabb.max}.bottom(); case omath::primitives::UpAxis::Y: - return aabb.bottom(); + return aabb.bottom(); case omath::primitives::UpAxis::Z: - return aabb.bottom(); + return omath::primitives::Aabb{aabb.min, aabb.max}.bottom(); } std::unreachable(); } diff --git a/tests/general/unit_test_aabb.cpp b/tests/general/unit_test_aabb.cpp index 02d3a904..65a11fee 100644 --- a/tests/general/unit_test_aabb.cpp +++ b/tests/general/unit_test_aabb.cpp @@ -4,7 +4,9 @@ #include #include "omath/3d_primitives/aabb.hpp" +using UpAxis = omath::primitives::UpAxis; using AABB = omath::primitives::Aabb; +using AABBZ = omath::primitives::Aabb; using Vec3 = omath::Vector3; // --- 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(); + 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(); + 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 auto t = box.top(); + constexpr AABBZ box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}}; + 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 auto t = box.top(); + constexpr AABBZ box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}}; + 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()); + 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(); + 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(); + 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 auto b = box.bottom(); + constexpr AABBZ box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}}; + 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 auto b = box.bottom(); + constexpr AABBZ box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}}; + 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()); + 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().y, -box.bottom().y); - EXPECT_FLOAT_EQ(box.top().z, -box.bottom().z); + constexpr AABBZ z_up_box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}}; + EXPECT_FLOAT_EQ(box.top().y, -box.bottom().y); + EXPECT_FLOAT_EQ(z_up_box.top().z, -z_up_box.bottom().z); +} + +// --- vertices() --- + +TEST(AabbTests, VerticesReturnsAllCorners) +{ + constexpr AABB box{{1.f, 2.f, 3.f}, {4.f, 6.f, 8.f}}; + constexpr auto v = box.vertices(); + + EXPECT_EQ(v[0], Vec3(1.f, 2.f, 3.f)); + EXPECT_EQ(v[1], Vec3(4.f, 2.f, 3.f)); + EXPECT_EQ(v[2], Vec3(1.f, 6.f, 3.f)); + EXPECT_EQ(v[3], Vec3(4.f, 6.f, 3.f)); + EXPECT_EQ(v[4], Vec3(1.f, 2.f, 8.f)); + EXPECT_EQ(v[5], Vec3(4.f, 2.f, 8.f)); + EXPECT_EQ(v[6], Vec3(1.f, 6.f, 8.f)); + EXPECT_EQ(v[7], Vec3(4.f, 6.f, 8.f)); } // --- is_collide() ---