GUI: D3D12 web view backend and disk-served UI schemes

code/framework/CMakeLists.txt

@@ -91,9 +91,11 @@ list(APPEND FRAMEWORK_CLIENT_SRC
     src/gui/view.cpp
     src/gui/sdk.cpp
     src/gui/backend/view_d3d11.cpp
+    src/gui/backend/view_d3d12.cpp
     src/gui/cef/app.cpp
     src/gui/cef/renderer_app.cpp
     src/gui/cef/client.cpp
+    src/gui/cef/disk_resource_handler.cpp
     src/gui/cef/render_handler.cpp
     src/gui/cef/life_span_handler.cpp
     src/gui/cef/load_handler.cpp

code/framework/src/graphics/backend/d3d12.cpp

@@ -9,18 +9,25 @@
 #include "d3d12.h"
 
 #include <logging/logger.h>
+#include <utils/process_shutdown.h>
+
+#include <wrl/client.h>
 
 namespace Framework::Graphics {
     bool D3D12Backend::Init(const Framework::Graphics::RendererConfiguration &opts) {
         const auto swapChain = opts.d3d12.swapchain;
         const auto commandQueue = opts.d3d12.commandQueue;
-        _device  = opts.d3d12.device;
         _context = opts.d3d12.deviceContext;
-        // #1 get device from swapchain (maybe different device)
+        // #1 get device from swapchain — and use it as THE device everywhere:
+        // descriptor heaps/RTVs below are created from it, so SRVs, textures
+        // and fences created later through GetDevice() must match or D3D12
+        // rejects the mixed-device usage. opts.d3d12.device is ignored if it
+        // differs.
         ID3D12Device *pD3DDevice;
         if (FAILED(swapChain->GetDevice(__uuidof(ID3D12Device), (void **)&pD3DDevice))) {
             return false;
         }
+        _device = pD3DDevice;
 
         _swapChain    = swapChain;
         _commandQueue = commandQueue;
@@ -39,12 +46,21 @@ namespace Framework::Graphics {
         {
             D3D12_DESCRIPTOR_HEAP_DESC desc {};
             desc.Type           = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
-            desc.NumDescriptors = _frameBufferCount;
+            desc.NumDescriptors = _frameBufferCount + kExtraSrvSlots;
             desc.Flags          = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
 
             if (pD3DDevice->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&_srvHeap)) != S_OK) {
                 return false;
             }
+
+            _srvDescriptorSize = pD3DDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+
+            // Slots [0, _frameBufferCount) stay reserved for ImGui (its font SRV
+            // sits at the heap start); the rest are up for allocation
+            _freeSrvSlots.clear();
+            for (UINT i = 0; i < kExtraSrvSlots; i++) {
+                _freeSrvSlots.push_back(_frameBufferCount + i);
+            }
         }
 
         // #3 create rtv heap
@@ -62,10 +78,11 @@ namespace Framework::Graphics {
             const auto rtvDescriptorSize          = pD3DDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
             D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = _rtvHeap->GetCPUDescriptorHandleForHeapStart();
 
+            // Reserve one RTV descriptor slot per frame index; the back-buffer
+            // resource (and its RTV) is bound fresh each frame in Begin(), so we
+            // don't grab the buffers here.
             for (UINT i = 0; i < _frameBufferCount; i++) {
                 _frameContext[i]._mainRenderTargetDescriptor = rtvHandle;
-                swapChain->GetBuffer(i, IID_PPV_ARGS(&_frameContext[i]._mainRenderTargetResource));
-                pD3DDevice->CreateRenderTargetView(_frameContext[i]._mainRenderTargetResource, nullptr, rtvHandle);
                 rtvHandle.ptr += rtvDescriptorSize;
             }
         }
@@ -93,22 +110,37 @@ namespace Framework::Graphics {
 
     void D3D12Backend::Shutdown() {
         // release objects
+        if (_currentBackBuffer) {
+            _currentBackBuffer->Release();
+            _currentBackBuffer = nullptr;
+        }
         _rtvHeap->Release();
         _srvHeap->Release();
         _commandList->Release();
         for (const auto &frameContext : _frameContext) {
             frameContext._commandAllocator->Release();
-            frameContext._mainRenderTargetResource->Release();
         }
     }
 
     void D3D12Backend::Begin() {
-        const auto &currentFrameContext = _frameContext[_swapChain->GetCurrentBackBufferIndex()];
+        const UINT idx                  = _swapChain->GetCurrentBackBufferIndex();
+        const auto &currentFrameContext = _frameContext[idx];
         currentFrameContext._commandAllocator->Reset();
 
+        // Acquire the current back buffer fresh (AddRef'd) and bind its RTV. It is
+        // released in End() — we never hold it across frames. The swapchain owns
+        // the buffer, so dropping our reference doesn't free it; the GPU keeps
+        // reading it for this frame via the swapchain's own hold.
+        _currentBackBuffer = nullptr;
+        if (FAILED(_swapChain->GetBuffer(idx, IID_PPV_ARGS(&_currentBackBuffer)))) {
+            _currentBackBuffer = nullptr;
+            return;
+        }
+        _device->CreateRenderTargetView(_currentBackBuffer, nullptr, currentFrameContext._mainRenderTargetDescriptor);
+
         _barrier.Type                   = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
         _barrier.Flags                  = D3D12_RESOURCE_BARRIER_FLAG_NONE;
-        _barrier.Transition.pResource   = currentFrameContext._mainRenderTargetResource;
+        _barrier.Transition.pResource   = _currentBackBuffer;
         _barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
         _barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
         _barrier.Transition.StateAfter  = D3D12_RESOURCE_STATE_RENDER_TARGET;
@@ -120,16 +152,116 @@ namespace Framework::Graphics {
     }
 
     void D3D12Backend::End() {
+        if (!_currentBackBuffer) {
+            return;  // Begin() failed to acquire this frame
+        }
+
         _barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
         _barrier.Transition.StateAfter  = D3D12_RESOURCE_STATE_PRESENT;
         _commandList->ResourceBarrier(1, &_barrier);
         _commandList->Close();
         _commandQueue->ExecuteCommandLists(1, (ID3D12CommandList **)&_commandList);
+
+        // Drop our per-frame reference now that the work is submitted. Safe: the
+        // swapchain still owns the buffer, so it stays alive for the GPU.
+        _currentBackBuffer->Release();
+        _currentBackBuffer = nullptr;
     }
 
     void D3D12Backend::Update() {}
 
     int D3D12Backend::NumFramesInFlight() const {
         return _frameBufferCount;
     }
+
+    int D3D12Backend::AllocateSRVSlot() {
+        if (!_srvHeap) {
+            Framework::Logging::GetLogger(FRAMEWORK_INNER_GRAPHICS)->error("D3D12Backend::AllocateSRVSlot, no descriptor heap");
+            return -1;
+        }
+        if (_freeSrvSlots.empty()) {
+            Framework::Logging::GetLogger(FRAMEWORK_INNER_GRAPHICS)->error("D3D12Backend::AllocateSRVSlot, heap exhausted");
+            return -1;
+        }
+        const auto slot = _freeSrvSlots.back();
+        _freeSrvSlots.pop_back();
+        return static_cast<int>(slot);
+    }
+
+    void D3D12Backend::FreeSRVSlot(int slot) {
+        if (slot < 0) {
+            return;
+        }
+        _freeSrvSlots.push_back(static_cast<UINT>(slot));
+    }
+
+    D3D12_CPU_DESCRIPTOR_HANDLE D3D12Backend::GetSRVSlotCPUHandle(int slot) const {
+        if (!_srvHeap) {
+            return {};
+        }
+        auto handle = _srvHeap->GetCPUDescriptorHandleForHeapStart();
+        handle.ptr += static_cast<SIZE_T>(slot) * _srvDescriptorSize;
+        return handle;
+    }
+
+    D3D12_GPU_DESCRIPTOR_HANDLE D3D12Backend::GetSRVSlotGPUHandle(int slot) const {
+        if (!_srvHeap) {
+            return {};
+        }
+        auto handle = _srvHeap->GetGPUDescriptorHandleForHeapStart();
+        handle.ptr += static_cast<UINT64>(slot) * _srvDescriptorSize;
+        return handle;
+    }
+
+    bool D3D12Backend::WaitForGpu() {
+        if (!_commandQueue || !_device) {
+            return true; // nothing to drain
+        }
+
+        // During process teardown the game has already destroyed its device and
+        // queue; touching them is UB and the fence would never signal anyway.
+        // Freeing without the drain is safe here - in-flight work died with
+        // the queue's threads
+        if (Framework::Utils::IsProcessShutdownInProgress()) {
+            return true;
+        }
+
+        Microsoft::WRL::ComPtr<ID3D12Fence> fence;
+        if (FAILED(_device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&fence)))) {
+            Framework::Logging::GetLogger(FRAMEWORK_INNER_GRAPHICS)->error("D3D12Backend::WaitForGpu, CreateFence failed");
+            return false;
+        }
+
+        const HANDLE event = CreateEventW(nullptr, FALSE, FALSE, nullptr);
+        if (!event) {
+            Framework::Logging::GetLogger(FRAMEWORK_INNER_GRAPHICS)->error("D3D12Backend::WaitForGpu, CreateEvent failed");
+            return false;
+        }
+
+        bool drained = false;
+        if (FAILED(_commandQueue->Signal(fence.Get(), 1))) {
+            // Generally means the device was removed; in-flight work is dead,
+            // but we can't prove it, so report failure and let callers decide
+            Framework::Logging::GetLogger(FRAMEWORK_INNER_GRAPHICS)->error("D3D12Backend::WaitForGpu, queue Signal failed (device removed?)");
+        }
+        else if (fence->GetCompletedValue() >= 1) {
+            drained = true;
+        }
+        else if (SUCCEEDED(fence->SetEventOnCompletion(1, event))) {
+            // A live GPU signals in single-digit ms; the timeout only bites
+            // when the queue is wedged - which is precisely when freeing
+            // GPU-referenced resources is unsafe, hence the failure return
+            if (WaitForSingleObject(event, 500) == WAIT_OBJECT_0 || fence->GetCompletedValue() >= 1) {
+                drained = true;
+            }
+            else {
+                Framework::Logging::GetLogger(FRAMEWORK_INNER_GRAPHICS)->error("D3D12Backend::WaitForGpu, fence wait timed out");
+            }
+        }
+        else {
+            Framework::Logging::GetLogger(FRAMEWORK_INNER_GRAPHICS)->error("D3D12Backend::WaitForGpu, SetEventOnCompletion failed");
+        }
+        CloseHandle(event);
+        return drained;
+    }
 } // namespace Framework::Graphics

code/framework/src/graphics/backend/d3d12.h

@@ -15,6 +15,11 @@
 
 namespace Framework::Graphics {
     class D3D12Backend: public Backend<ID3D12Device *, ID3D12DeviceContext *, IDXGISwapChain3 *, ID3D12CommandQueue *> {
+      public:
+        // Extra shader-visible SRV slots reserved after the ImGui font slot(s),
+        // handed out to web views via AllocateSRVSlot
+        static constexpr UINT kExtraSrvSlots = 64;
+
       private:
         IDXGISwapChain3 *_swapChain             = nullptr;
         UINT _frameBufferCount                  = 0;
@@ -23,15 +28,23 @@ namespace Framework::Graphics {
         ID3D12GraphicsCommandList *_commandList = nullptr;
         ID3D12CommandQueue *_commandQueue       = nullptr;
 
+        UINT _srvDescriptorSize = 0;
+        std::vector<UINT> _freeSrvSlots;
+
         struct FrameContext {
             ID3D12CommandAllocator *_commandAllocator = nullptr;
-            ID3D12Resource *_mainRenderTargetResource = nullptr;
             D3D12_CPU_DESCRIPTOR_HANDLE _mainRenderTargetDescriptor;
         };
 
         std::vector<FrameContext> _frameContext;
         D3D12_RESOURCE_BARRIER _barrier {};
 
+        // The current frame's back buffer, acquired fresh in Begin() and released
+        // in End(). We deliberately never hold a swapchain reference across
+        // frames so the game can resize/recreate the swapchain (which happens
+        // between presents) without our reference blocking DXGI's ResizeBuffers.
+        ID3D12Resource *_currentBackBuffer = nullptr;
+
       public:
         bool Init(const Framework::Graphics::RendererConfiguration &opts) override;
         void Shutdown() override;
@@ -40,6 +53,16 @@ namespace Framework::Graphics {
         void End();
         int NumFramesInFlight() const;
 
+        // Since we no longer cache the back buffers, a swapchain resize or even a
+        // full swapchain recreation needs nothing from us beyond pointing at the
+        // current swapchain — Begin() re-acquires the back buffer each frame.
+        IDXGISwapChain3 *GetSwapChain() const {
+            return _swapChain;
+        }
+        void SetSwapChain(IDXGISwapChain3 *swapChain) {
+            _swapChain = swapChain;
+        }
+
         // TODO: Backend not implemented yet
         void BeginDrawing() {}
         void EndDrawing() {}
@@ -66,5 +89,29 @@ namespace Framework::Graphics {
         ID3D12GraphicsCommandList *GetGraphicsCommandList() const {
             return _commandList;
         }
+
+        UINT GetCurrentFrameIndex() const {
+            return _swapChain ? _swapChain->GetCurrentBackBufferIndex() : 0;
+        }
+
+        // Allocates a shader-visible SRV slot from the backend heap (the one ImGui
+        // is initialized against, so handles are usable as ImTextureID). Returns -1
+        // when exhausted.
+        int AllocateSRVSlot();
+        void FreeSRVSlot(int slot);
+        D3D12_CPU_DESCRIPTOR_HANDLE GetSRVSlotCPUHandle(int slot) const;
+        D3D12_GPU_DESCRIPTOR_HANDLE GetSRVSlotGPUHandle(int slot) const;
+
+        // Blocks until the GPU has drained the queue. Used before destroying
+        // resources that in-flight command lists may still reference. Returns
+        // false when the drain could not be confirmed (fence timeout/failure)
+        // so callers can refuse to free still-referenced resources; returns
+        // true during process teardown, where waiting is impossible and
+        // freeing is safe (the queue's threads are already gone).
+        [[nodiscard]] bool WaitForGpu();
+
+        size_t GetFreeSRVSlotCount() const {
+            return _freeSrvSlots.size();
+        }
     };
 } // namespace Framework::Graphics

code/framework/src/graphics/renderer.cpp

@@ -21,7 +21,8 @@ namespace Framework::Graphics {
             return RendererError::RENDERER_ALREADY_INITIALIZED;
         }
 
-        _config = config;
+        _config  = config;
+        _backend = config.backend;
 
         if (_config.backend == RendererBackend::BACKEND_D3D_11) {
             _d3d11Backend = std::make_unique<D3D11Backend>();

code/framework/src/gui/backend/view_d3d11.cpp

@@ -175,25 +175,31 @@ namespace Framework::GUI {
         else {
             // CPU path: use pixel data from CEF's OnPaint
             auto *renderHandler = GetRenderHandler();
-            if (renderHandler && !renderHandler->GetPixelData().empty()) {
-                Graphics::Bitmap bmp;
-                bmp.format = Graphics::BitmapFormat::BGRA8;
-                bmp.width  = _width;
-                bmp.height = _height;
-                bmp.pitch  = _width * 4;
-                bmp.size   = static_cast<uint32_t>(renderHandler->GetPixelData().size());
-                bmp.pixels = const_cast<uint8_t *>(renderHandler->GetPixelData().data());
-
-                if (_cpuTextureID == 0) {
-                    _cpuTextureID = backend->NextTextureId();
-                    backend->CreateTexture(_cpuTextureID, bmp);
-                }
-                else if (renderHandler->IsPixelDataDirty()) {
-                    backend->UpdateTexture(_cpuTextureID, bmp);
-                    renderHandler->ClearPixelDataDirty();
-                }
+            if (renderHandler) {
+                // Held for the whole read — OnPaint reallocates the buffer on
+                // resize
+                const auto pixelLock = renderHandler->LockPixels();
+
+                if (!renderHandler->GetPixelData().empty()) {
+                    Graphics::Bitmap bmp;
+                    bmp.format = Graphics::BitmapFormat::BGRA8;
+                    bmp.width  = _width;
+                    bmp.height = _height;
+                    bmp.pitch  = _width * 4;
+                    bmp.size   = static_cast<uint32_t>(renderHandler->GetPixelData().size());
+                    bmp.pixels = const_cast<uint8_t *>(renderHandler->GetPixelData().data());
+
+                    if (_cpuTextureID == 0) {
+                        _cpuTextureID = backend->NextTextureId();
+                        backend->CreateTexture(_cpuTextureID, bmp);
+                    }
+                    else if (renderHandler->IsPixelDataDirty()) {
+                        backend->UpdateTexture(_cpuTextureID, bmp);
+                        renderHandler->ClearPixelDataDirty();
+                    }
 
-                gpuState.texture_1_id = _cpuTextureID;
+                    gpuState.texture_1_id = _cpuTextureID;
+                }
             }
         }