[D3D11] Notify all binding tables when resources are released (fixes #…

…126).

- Evict all bindings from binding tables when buffer, texture, or render-target is released.
- Keep reference to state manager of all deferred device contexts so they can be notified as well.
- Updated ResourceBinding unit test to delete and re-create resources intermittently.

sources/Renderer/Direct3D11/Command/D3D11CommandContext.h

@@ -91,6 +91,12 @@ class D3D11CommandContext
             return context_.Get();
         }
 
+        // Returns a pointer to the state manager for this command context.
+        inline D3D11StateManager* GetStateManagerPtr() const
+        {
+            return stateMngr_.get();
+        }
+
         // Returns the state manager for this command context.
         inline D3D11StateManager& GetStateManager() const
         {

sources/Renderer/Direct3D11/Command/D3D11PrimaryCommandBuffer.h

@@ -44,28 +44,19 @@ class D3D11PrimaryCommandBuffer final : public D3D11CommandBuffer
             return commandList_.Get();
         }
 
-    private:
-
-        void ClearWithIntermediateUAV(ID3D11Buffer* buffer, UINT offset, UINT size, const UINT (&valuesVec4)[4]);
-
-        // Creates a copy of this buffer as ByteAddressBuffer; 'size' must be a multiple of 4.
-        void CreateByteAddressBufferR32Typeless(
-            ID3D11Device*               device,
-            ID3D11DeviceContext*        context,
-            ID3D11Buffer**              bufferOutput,
-            ID3D11ShaderResourceView**  srvOutput,
-            ID3D11UnorderedAccessView** uavOutput,
-            UINT                        size,
-            D3D11_USAGE                 usage           = D3D11_USAGE_DEFAULT
-        );
-
         // Returns the native D3D11 device context.
         inline ID3D11DeviceContext* GetNative() const
         {
             return context_.GetNative();
         }
 
-        // Returns the state manager for this command context.
+        // Returns a pointer to the state manager for this command buffer.
+        inline D3D11StateManager* GetStateManagerPtr() const
+        {
+            return context_.GetStateManagerPtr();
+        }
+
+        // Returns the state manager for this command buffer.
         inline D3D11StateManager& GetStateManager() const
         {
             return context_.GetStateManager();
@@ -77,6 +68,21 @@ class D3D11PrimaryCommandBuffer final : public D3D11CommandBuffer
             return context_.GetBindingTable();
         }
 
+    private:
+
+        void ClearWithIntermediateUAV(ID3D11Buffer* buffer, UINT offset, UINT size, const UINT (&valuesVec4)[4]);
+
+        // Creates a copy of this buffer as ByteAddressBuffer; 'size' must be a multiple of 4.
+        void CreateByteAddressBufferR32Typeless(
+            ID3D11Device*               device,
+            ID3D11DeviceContext*        context,
+            ID3D11Buffer**              bufferOutput,
+            ID3D11ShaderResourceView**  srvOutput,
+            ID3D11UnorderedAccessView** uavOutput,
+            UINT                        size,
+            D3D11_USAGE                 usage           = D3D11_USAGE_DEFAULT
+        );
+
     private:
 
         // Device object to create on-demand objects like temporary SRVs and UAVs

sources/Renderer/Direct3D11/D3D11RenderSystem.cpp

@@ -126,13 +126,32 @@ CommandBuffer* D3D11RenderSystem::CreateCommandBuffer(const CommandBufferDescrip
         /* Create state manager dedicated to deferred context */
         std::shared_ptr<D3D11StateManager> deferredStateMngr = std::make_shared<D3D11StateManager>(device_.Get(), deferredContext);
 
+        /* Store references to unique state manager - we need to notify all binding tables on resource release */
+        deferredStateMngrRefs_.push_back(deferredStateMngr.get());
+
         /* Create command buffer with deferred context and dedicated state manager */
         return commandBuffers_.emplace<D3D11PrimaryCommandBuffer>(device_.Get(), deferredContext, std::move(deferredStateMngr), commandBufferDesc);
     }
 }
 
 void D3D11RenderSystem::Release(CommandBuffer& commandBuffer)
 {
+    auto& commandBufferD3D = LLGL_CAST(D3D11CommandBuffer, commandBuffer);
+    if (!commandBufferD3D.IsSecondaryCmdBuffer())
+    {
+        /* If this is command buffer has a unique state manager, remove it from the list of deferred state managers */
+        auto& primaryCmdBufferD3D = LLGL_CAST(D3D11PrimaryCommandBuffer, commandBufferD3D);
+        if (primaryCmdBufferD3D.GetStateManagerPtr() != stateMngr_.get())
+        {
+            RemoveFromListIf(
+                deferredStateMngrRefs_,
+                [stateMngr = primaryCmdBufferD3D.GetStateManagerPtr()](D3D11StateManager* entry) -> bool
+                {
+                    return (entry == stateMngr);
+                }
+            );
+        }
+    }
     commandBuffers_.erase(&commandBuffer);
 }
 
@@ -155,6 +174,8 @@ BufferArray* D3D11RenderSystem::CreateBufferArray(std::uint32_t numBuffers, Buff
 
 void D3D11RenderSystem::Release(Buffer& buffer)
 {
+    auto& bufferD3D = LLGL_CAST(D3D11Buffer&, buffer);
+    NotifyBindingTablesOnRelease(bufferD3D.GetBindingLocator());
     buffers_.erase(&buffer);
 }
 
@@ -212,6 +233,8 @@ Texture* D3D11RenderSystem::CreateTexture(const TextureDescriptor& textureDesc,
 
 void D3D11RenderSystem::Release(Texture& texture)
 {
+    auto& textureD3D = LLGL_CAST(D3D11Texture&, texture);
+    NotifyBindingTablesOnRelease(textureD3D.GetBindingLocator());
     textures_.erase(&texture);
 }
 
@@ -377,6 +400,11 @@ RenderTarget* D3D11RenderSystem::CreateRenderTarget(const RenderTargetDescriptor
 
 void D3D11RenderSystem::Release(RenderTarget& renderTarget)
 {
+    auto& renderTargetD3D = LLGL_CAST(D3D11RenderTarget&, renderTarget);
+    const D3D11RenderTargetHandles& rtHandles = renderTargetD3D.GetRenderTargetHandles();
+    NotifyBindingTablesOnRelease(rtHandles.GetDepthStencilLocator());
+    for_range(i, rtHandles.GetNumRenderTargetViews())
+        NotifyBindingTablesOnRelease(rtHandles.GetRenderTargetLocators()[i]);
     renderTargets_.erase(&renderTarget);
 }
 
@@ -1097,6 +1125,19 @@ bool D3D11RenderSystem::CheckFactoryFeatureSupport(DXGI_FEATURE feature) const
 
 #endif
 
+void D3D11RenderSystem::NotifyBindingTablesOnRelease(D3D11BindingLocator* locator)
+{
+    if (locator != nullptr)
+    {
+        /* Notify state manager that is shared across the primary D3D device context */
+        stateMngr_->GetBindingTable().NotifyResourceRelease(locator);
+
+        /* Notify state managers for all deferred device contexts */
+        for (D3D11StateManager* deferredStateMngr : deferredStateMngrRefs_)
+            deferredStateMngr->GetBindingTable().NotifyResourceRelease(locator);
+    }
+}
+
 
 } // /namespace LLGL
 

sources/Renderer/Direct3D11/D3D11RenderSystem.h

@@ -130,6 +130,8 @@ class D3D11RenderSystem final : public RenderSystem
         bool CheckFactoryFeatureSupport(DXGI_FEATURE feature) const;
         #endif
 
+        void NotifyBindingTablesOnRelease(D3D11BindingLocator* locator);
+
     private:
 
         /* ----- Common objects ----- */
@@ -164,6 +166,7 @@ class D3D11RenderSystem final : public RenderSystem
         bool                                    tearingSupported_       = false;
 
         std::shared_ptr<D3D11StateManager>      stateMngr_;
+        std::vector<D3D11StateManager*>         deferredStateMngrRefs_;
 
         /* ----- Hardware object containers ----- */
 

sources/Renderer/Direct3D11/RenderState/D3D11BindingTable.cpp

@@ -249,6 +249,7 @@ void D3D11BindingTable::SetRenderTargets(
 
 void D3D11BindingTable::ClearState()
 {
+    /* Clear binding locators from all tables */
     ClearBindingLocators(vb_);
     ClearBindingLocators(ib_);
     ClearBindingLocators(srvVS_);
@@ -279,16 +280,23 @@ void D3D11BindingTable::FlushOutputMergerUAVs()
     }
 }
 
+void D3D11BindingTable::NotifyResourceRelease(D3D11BindingLocator* locator)
+{
+    /* When a resource is about to be released, evict all of its bindings from this binding table */
+    EvictAllBindings(locator);
+}
+
 
 /*
  * ======= Private: =======
  */
 
+static void* const g_nullArray[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = {};
+
 template <typename T>
 static T* const* GetNullPointerArray()
 {
-    static void* const nullArray[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = {};
-    return reinterpret_cast<T* const*>(nullArray);
+    return reinterpret_cast<T* const*>(g_nullArray);
 }
 
 void D3D11BindingTable::InsertInput(D3D11BindingLocator** container, D3D11BindingLocator::D3DInputs input, UINT slot, D3D11BindingLocator* locator)

sources/Renderer/Direct3D11/RenderState/D3D11BindingTable.h

@@ -99,11 +99,15 @@ class D3D11BindingTable
             D3D11BindingLocator*            depthStencilLocators
         );
 
+        // Clears the binding table state but doesn't perform any operations on the D3D device context.
         void ClearState();
 
         // Binds all pending output merger UAVs to the device context if they have previosuly changed.
         void FlushOutputMergerUAVs();
 
+        // Notifies the binding table that a resource, represented by the specified binding locator, is about to be released.
+        void NotifyResourceRelease(D3D11BindingLocator* locator);
+
     private:
 
         using D3D11BindingLocatorIterator = SparseForwardIterator<D3D11BindingLocator*>;