Fixes to the Dx11 resource management

OptiScaler/shaders/bias/Bias_Dx11.cpp

@@ -42,6 +42,7 @@ bool Bias_Dx11::CreateBufferResource(ID3D11Device* InDevice, ID3D11Resource* InR
         return false;
 
     D3D11_TEXTURE2D_DESC texDesc;
+    originalTexture->Release();
     originalTexture->GetDesc(&texDesc);
 
     if (_buffer != nullptr)

OptiScaler/shaders/depth_transfer/DT_Dx11.cpp

@@ -17,6 +17,7 @@ bool DepthTransfer_Dx11::CreateBufferResource(ID3D11Device* InDevice, ID3D11Reso
         return false;
 
     D3D11_TEXTURE2D_DESC texDesc;
+    originalTexture->Release();
     originalTexture->GetDesc(&texDesc);
 
     texDesc.Format = DXGI_FORMAT_R32_FLOAT;

OptiScaler/shaders/output_scaling/OS_Dx11.cpp

@@ -63,6 +63,7 @@ bool OS_Dx11::CreateBufferResource(ID3D11Device* InDevice, ID3D11Resource* InRes
         return false;
 
     D3D11_TEXTURE2D_DESC texDesc;
+    originalTexture->Release();
     originalTexture->GetDesc(&texDesc);
     auto targetWidth = texDesc.Width > InWidth ? texDesc.Width : InWidth;
     auto targetHeight = texDesc.Height > InHeight ? texDesc.Height : InHeight;

OptiScaler/shaders/rcas/RCAS_Dx11.cpp

@@ -137,6 +137,7 @@ bool RCAS_Dx11::CreateBufferResource(ID3D11Device* InDevice, ID3D11Resource* InR
         return false;
 
     D3D11_TEXTURE2D_DESC texDesc;
+    originalTexture->Release();
     originalTexture->GetDesc(&texDesc);
 
     if (_buffer != nullptr)

OptiScaler/upscalers/IFeature_Dx11wDx12.cpp

@@ -49,6 +49,7 @@ bool IFeature_Dx11wDx12::CopyTextureFrom11To12(ID3D11Resource* InResource, D3D11
     if (result != S_OK || originalTexture == nullptr)
         return false;
 
+    originalTexture->Release();
     originalTexture->GetDesc(&desc);
 
     // check shared nt handle usage later
@@ -95,6 +96,8 @@ bool IFeature_Dx11wDx12::CopyTextureFrom11To12(ID3D11Resource* InResource, D3D11
                 return false;
             }
 
+            resource->Release();
+
             // Get shared handle
             DWORD access = DXGI_SHARED_RESOURCE_READ;
 
@@ -108,8 +111,6 @@ bool IFeature_Dx11wDx12::CopyTextureFrom11To12(ID3D11Resource* InResource, D3D11
                 LOG_ERROR("GetSharedHandle error: {0:x}", result);
                 return false;
             }
-
-            resource->Release();
         }
 
         if (InCopy && OutResource->SharedTexture != nullptr)
@@ -136,6 +137,8 @@ bool IFeature_Dx11wDx12::CopyTextureFrom11To12(ID3D11Resource* InResource, D3D11
                     return false;
                 }
 
+                resource->Release();
+
                 // Get shared handle
                 result = resource->GetSharedHandle(&OutResource->Dx11Handle);
 
@@ -145,8 +148,6 @@ bool IFeature_Dx11wDx12::CopyTextureFrom11To12(ID3D11Resource* InResource, D3D11
                     resource->Release();
                     return false;
                 }
-
-                resource->Release();
             }
         }
         else
@@ -186,6 +187,8 @@ bool IFeature_Dx11wDx12::CopyTextureFrom11To12(ID3D11Resource* InResource, D3D11
                     return false;
                 }
 
+                resource->Release();
+
                 // Get shared handle
                 result = resource->GetSharedHandle(&OutResource->Dx11Handle);
 
@@ -195,8 +198,6 @@ bool IFeature_Dx11wDx12::CopyTextureFrom11To12(ID3D11Resource* InResource, D3D11
                     resource->Release();
                     return false;
                 }
-
-                resource->Release();
             }
 
             if (InCopy && OutResource->SharedTexture != nullptr)
@@ -217,6 +218,8 @@ bool IFeature_Dx11wDx12::CopyTextureFrom11To12(ID3D11Resource* InResource, D3D11
                 return false;
             }
 
+            resource->Release();
+
             // Get shared handle
             if ((desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED) != 0 &&
                 (desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE) != 0)
@@ -239,13 +242,10 @@ bool IFeature_Dx11wDx12::CopyTextureFrom11To12(ID3D11Resource* InResource, D3D11
                 return false;
             }
 
-            resource->Release();
-
             OutResource->SharedTexture = (ID3D11Texture2D*) InResource;
         }
     }
 
-    originalTexture->Release();
     return true;
 }
 
@@ -336,6 +336,8 @@ void IFeature_Dx11wDx12::GetHardwareAdapter(IDXGIFactory1* InFactory, IDXGIAdapt
             //     break;
             //}
         }
+
+        factory6->Release();
     }
     else
     {
@@ -718,6 +720,8 @@ bool IFeature_Dx11wDx12::ProcessDx11Textures(const NVSDK_NGX_Parameter* InParame
 
     if (paramColor && dx11Color.Dx12Handle != dx11Color.Dx11Handle)
     {
+        SAFE_RELEASE(dx11Color.Dx12Resource);
+
         if (dx11Color.Dx12Handle != NULL)
             CloseHandle(dx11Color.Dx12Handle);
 
@@ -734,6 +738,8 @@ bool IFeature_Dx11wDx12::ProcessDx11Textures(const NVSDK_NGX_Parameter* InParame
 
     if (paramMv && dx11Mv.Dx12Handle != dx11Mv.Dx11Handle)
     {
+        SAFE_RELEASE(dx11Mv.Dx12Resource);
+
         if (dx11Mv.Dx12Handle != NULL)
             CloseHandle(dx11Mv.Dx12Handle);
 
@@ -745,11 +751,13 @@ bool IFeature_Dx11wDx12::ProcessDx11Textures(const NVSDK_NGX_Parameter* InParame
             return false;
         }
 
-        dx11Mv.Dx11Handle = dx11Mv.Dx12Handle;
+        dx11Mv.Dx12Handle = dx11Mv.Dx11Handle;
     }
 
     if (paramOutput[_frameCount % 2] && dx11Out.Dx12Handle != dx11Out.Dx11Handle)
     {
+        SAFE_RELEASE(dx11Out.Dx12Resource);
+
         if (dx11Out.Dx12Handle != NULL)
             CloseHandle(dx11Out.Dx12Handle);
 
@@ -766,6 +774,8 @@ bool IFeature_Dx11wDx12::ProcessDx11Textures(const NVSDK_NGX_Parameter* InParame
 
     if (paramDepth && dx11Depth.Dx12Handle != dx11Depth.Dx11Handle)
     {
+        SAFE_RELEASE(dx11Depth.Dx12Resource);
+
         if (dx11Depth.Dx12Handle != NULL)
             CloseHandle(dx11Depth.Dx12Handle);
 
@@ -788,6 +798,8 @@ bool IFeature_Dx11wDx12::ProcessDx11Textures(const NVSDK_NGX_Parameter* InParame
     }
     else if (paramExposure && dx11Exp.Dx12Handle != dx11Exp.Dx11Handle)
     {
+        SAFE_RELEASE(dx11Exp.Dx12Resource);
+
         if (dx11Exp.Dx12Handle != NULL)
             CloseHandle(dx11Exp.Dx12Handle);
 
@@ -805,6 +817,8 @@ bool IFeature_Dx11wDx12::ProcessDx11Textures(const NVSDK_NGX_Parameter* InParame
     if (!Config::Instance()->DisableReactiveMask.value_or(false) && paramReactiveMask &&
         dx11Reactive.Dx12Handle != dx11Reactive.Dx11Handle)
     {
+        SAFE_RELEASE(dx11Reactive.Dx12Resource);
+
         if (dx11Reactive.Dx12Handle != NULL)
             CloseHandle(dx11Reactive.Dx12Handle);
 
@@ -868,8 +882,13 @@ bool IFeature_Dx11wDx12::BaseInit(ID3D11Device* InDevice, ID3D11DeviceContext* I
     }
 
     if (!InDevice)
+    {
         Dx11DeviceContext->GetDevice(&InDevice);
 
+        if (InDevice)
+            InDevice->Release();
+    }
+
     auto dx11DeviceResult = InDevice->QueryInterface(IID_PPV_ARGS(&Dx11Device));
 
     if (dx11DeviceResult != S_OK)

OptiScaler/upscalers/dlss/DLSSFeature_Dx11.cpp

@@ -107,32 +107,61 @@ bool DLSSFeatureDx11::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NGX_P
         ID3D11SamplerState* restoreSamplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = {};
         ID3D11Buffer* restoreCBVs[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = {};
         ID3D11UnorderedAccessView* restoreUAVs[D3D11_1_UAV_SLOT_COUNT] = {};
+        ID3D11RenderTargetView* restoreRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+        ID3D11DepthStencilView* restoreDSV = nullptr;
 
         // backup compute shader resources
         for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
         {
             restoreSRVs[i] = nullptr;
             InDeviceContext->CSGetShaderResources(i, 1, &restoreSRVs[i]);
+
+            if (restoreSRVs[i])
+                restoreSRVs[i]->Release();
         }
 
         for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
         {
             restoreSamplerStates[i] = nullptr;
             InDeviceContext->CSGetSamplers(i, 1, &restoreSamplerStates[i]);
+
+            if (restoreSamplerStates[i])
+                restoreSamplerStates[i]->Release();
         }
 
         for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
         {
             restoreCBVs[i] = nullptr;
             InDeviceContext->CSGetConstantBuffers(i, 1, &restoreCBVs[i]);
+
+            if (restoreCBVs[i])
+                restoreCBVs[i]->Release();
         }
 
         for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
         {
             restoreUAVs[i] = nullptr;
             InDeviceContext->CSGetUnorderedAccessViews(i, 1, &restoreUAVs[i]);
+
+            if (restoreUAVs[i])
+                restoreUAVs[i]->Release();
         }
 
+        InDeviceContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
+
+        // Unbind RenderTargets
+        ID3D11RenderTargetView* nullRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+        InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
+
+        for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+        {
+            if (restoreRTVs[i])
+                restoreRTVs[i]->Release();
+        }
+
+        if (restoreDSV)
+            restoreDSV->Release();
+
         ProcessEvaluateParams(InParameters);
 
         ID3D11Resource* paramOutput = nullptr;
@@ -273,27 +302,25 @@ bool DLSSFeatureDx11::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NGX_P
         // restore compute shader resources
         for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
         {
-            if (restoreSRVs[i] != nullptr)
-                InDeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
+            InDeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
         }
 
         for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
         {
-            if (restoreSamplerStates[i] != nullptr)
-                InDeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
+            InDeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
         }
 
         for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
         {
-            if (restoreCBVs[i] != nullptr)
-                InDeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
+            InDeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
         }
 
         for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
         {
-            if (restoreUAVs[i] != nullptr)
-                InDeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
+            InDeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
         }
+
+        InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);
     }
     else
     {

OptiScaler/upscalers/dlssd/DLSSDFeature_Dx11.cpp

@@ -110,32 +110,61 @@ bool DLSSDFeatureDx11::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NGX_
         ID3D11SamplerState* restoreSamplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = {};
         ID3D11Buffer* restoreCBVs[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = {};
         ID3D11UnorderedAccessView* restoreUAVs[D3D11_1_UAV_SLOT_COUNT] = {};
+        ID3D11RenderTargetView* restoreRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+        ID3D11DepthStencilView* restoreDSV = nullptr;
 
         // backup compute shader resources
         for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
         {
             restoreSRVs[i] = nullptr;
             InDeviceContext->CSGetShaderResources(i, 1, &restoreSRVs[i]);
+
+            if (restoreSRVs[i])
+                restoreSRVs[i]->Release();
         }
 
         for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
         {
             restoreSamplerStates[i] = nullptr;
             InDeviceContext->CSGetSamplers(i, 1, &restoreSamplerStates[i]);
+
+            if (restoreSamplerStates[i])
+                restoreSamplerStates[i]->Release();
         }
 
         for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
         {
             restoreCBVs[i] = nullptr;
             InDeviceContext->CSGetConstantBuffers(i, 1, &restoreCBVs[i]);
+
+            if (restoreCBVs[i])
+                restoreCBVs[i]->Release();
         }
 
         for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
         {
             restoreUAVs[i] = nullptr;
             InDeviceContext->CSGetUnorderedAccessViews(i, 1, &restoreUAVs[i]);
+
+            if (restoreUAVs[i])
+                restoreUAVs[i]->Release();
         }
 
+        InDeviceContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
+
+        // Unbind RenderTargets
+        ID3D11RenderTargetView* nullRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+        InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
+
+        for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+        {
+            if (restoreRTVs[i])
+                restoreRTVs[i]->Release();
+        }
+
+        if (restoreDSV)
+            restoreDSV->Release();
+
         ProcessEvaluateParams(InParameters);
 
         ID3D11Resource* paramOutput = nullptr;
@@ -276,27 +305,25 @@ bool DLSSDFeatureDx11::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NGX_
         // restore compute shader resources
         for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
         {
-            if (restoreSRVs[i] != nullptr)
-                InDeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
+            InDeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
         }
 
         for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
         {
-            if (restoreSamplerStates[i] != nullptr)
-                InDeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
+            InDeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
         }
 
         for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
         {
-            if (restoreCBVs[i] != nullptr)
-                InDeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
+            InDeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
         }
 
         for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
         {
-            if (restoreUAVs[i] != nullptr)
-                InDeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
+            InDeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
         }
+
+        InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);
     }
     else
     {

OptiScaler/upscalers/fsr2/FSR2Feature_Dx11.cpp

@@ -56,6 +56,7 @@ bool FSR2FeatureDx11::CopyTexture(ID3D11Resource* InResource, D3D11_TEXTURE2D_RE
     if (result != S_OK)
         return false;
 
+    originalTexture->Release();
     originalTexture->GetDesc(&desc);
 
     if (desc.BindFlags == bindFlags)
@@ -264,31 +265,52 @@ bool FSR2FeatureDx11::Evaluate(ID3D11DeviceContext* InContext, NVSDK_NGX_Paramet
     {
         restoreSRVs[i] = nullptr;
         InContext->CSGetShaderResources(i, 1, &restoreSRVs[i]);
+
+        if (restoreSRVs[i])
+            restoreSRVs[i]->Release();
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
     {
         restoreSamplerStates[i] = nullptr;
         InContext->CSGetSamplers(i, 1, &restoreSamplerStates[i]);
+
+        if (restoreSamplerStates[i])
+            restoreSamplerStates[i]->Release();
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
     {
         restoreCBVs[i] = nullptr;
         InContext->CSGetConstantBuffers(i, 1, &restoreCBVs[i]);
+
+        if (restoreCBVs[i])
+            restoreCBVs[i]->Release();
     }
 
     for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
     {
         restoreUAVs[i] = nullptr;
         InContext->CSGetUnorderedAccessViews(i, 1, &restoreUAVs[i]);
+
+        if (restoreUAVs[i])
+            restoreUAVs[i]->Release();
     }
 
-    DeviceContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
+    InContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
 
     // Unbind RenderTargets
     ID3D11RenderTargetView* nullRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
-    DeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
+    InContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
+
+    for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+    {
+        if (restoreRTVs[i])
+            restoreRTVs[i]->Release();
+    }
+
+    if (restoreDSV)
+        restoreDSV->Release();
 
     FfxFsr2DispatchDescription params {};
     params.commandList = InContext;
@@ -613,29 +635,25 @@ bool FSR2FeatureDx11::Evaluate(ID3D11DeviceContext* InContext, NVSDK_NGX_Paramet
     // restore compute shader resources
     for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
     {
-        if (restoreSRVs[i] != nullptr)
-            InContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
+        InContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
     {
-        if (restoreSamplerStates[i] != nullptr)
-            InContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
+        InContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
     {
-        if (restoreCBVs[i] != nullptr)
-            InContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
+        InContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
     }
 
     for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
     {
-        if (restoreUAVs[i] != nullptr)
-            InContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
+        InContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
     }
 
-    DeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);
+    InContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);
 
     _frameCount++;
 

OptiScaler/upscalers/fsr2/FSR2Feature_Dx11On12.cpp

@@ -128,6 +128,65 @@ bool FSR2FeatureDx11on12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_N
     if (dc != nullptr)
         dc->Release();
 
+    ID3D11ShaderResourceView* restoreSRVs[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = {};
+    ID3D11SamplerState* restoreSamplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = {};
+    ID3D11Buffer* restoreCBVs[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = {};
+    ID3D11UnorderedAccessView* restoreUAVs[D3D11_1_UAV_SLOT_COUNT] = {};
+    ID3D11RenderTargetView* restoreRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    ID3D11DepthStencilView* restoreDSV = nullptr;
+
+    // backup compute shader resources
+    for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
+    {
+        restoreSRVs[i] = nullptr;
+        InDeviceContext->CSGetShaderResources(i, 1, &restoreSRVs[i]);
+
+        if (restoreSRVs[i])
+            restoreSRVs[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
+    {
+        restoreSamplerStates[i] = nullptr;
+        InDeviceContext->CSGetSamplers(i, 1, &restoreSamplerStates[i]);
+
+        if (restoreSamplerStates[i])
+            restoreSamplerStates[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
+    {
+        restoreCBVs[i] = nullptr;
+        InDeviceContext->CSGetConstantBuffers(i, 1, &restoreCBVs[i]);
+
+        if (restoreCBVs[i])
+            restoreCBVs[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+    {
+        restoreUAVs[i] = nullptr;
+        InDeviceContext->CSGetUnorderedAccessViews(i, 1, &restoreUAVs[i]);
+
+        if (restoreUAVs[i])
+            restoreUAVs[i]->Release();
+    }
+
+    InDeviceContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
+
+    // Unbind RenderTargets
+    ID3D11RenderTargetView* nullRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
+
+    for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+    {
+        if (restoreRTVs[i])
+            restoreRTVs[i]->Release();
+    }
+
+    if (restoreDSV)
+        restoreDSV->Release();
+
     FfxFsr2DispatchDescription params {};
 
     InParameters->Get(NVSDK_NGX_Parameter_Jitter_Offset_X, &params.jitterOffset.x);
@@ -442,6 +501,29 @@ bool FSR2FeatureDx11on12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_N
     _frameCount++;
     Dx12CommandQueue->Signal(Dx12Fence, _frameCount);
 
+    // restore compute shader resources
+    for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
+    }
+
+    InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);
+
     return evalResult;
 }
 

OptiScaler/upscalers/fsr2_212/FSR2Feature_Dx11On12_212.cpp

@@ -112,6 +112,65 @@ bool FSR2FeatureDx11on12_212::Evaluate(ID3D11DeviceContext* InDeviceContext, NVS
     if (Config::Instance()->DADepthIsLinear.value_for_config_ignore_default() == std::nullopt)
         Config::Instance()->DADepthIsLinear.set_volatile_value(false);
 
+    ID3D11ShaderResourceView* restoreSRVs[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = {};
+    ID3D11SamplerState* restoreSamplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = {};
+    ID3D11Buffer* restoreCBVs[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = {};
+    ID3D11UnorderedAccessView* restoreUAVs[D3D11_1_UAV_SLOT_COUNT] = {};
+    ID3D11RenderTargetView* restoreRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    ID3D11DepthStencilView* restoreDSV = nullptr;
+
+    // backup compute shader resources
+    for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
+    {
+        restoreSRVs[i] = nullptr;
+        InDeviceContext->CSGetShaderResources(i, 1, &restoreSRVs[i]);
+
+        if (restoreSRVs[i])
+            restoreSRVs[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
+    {
+        restoreSamplerStates[i] = nullptr;
+        InDeviceContext->CSGetSamplers(i, 1, &restoreSamplerStates[i]);
+
+        if (restoreSamplerStates[i])
+            restoreSamplerStates[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
+    {
+        restoreCBVs[i] = nullptr;
+        InDeviceContext->CSGetConstantBuffers(i, 1, &restoreCBVs[i]);
+
+        if (restoreCBVs[i])
+            restoreCBVs[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+    {
+        restoreUAVs[i] = nullptr;
+        InDeviceContext->CSGetUnorderedAccessViews(i, 1, &restoreUAVs[i]);
+
+        if (restoreUAVs[i])
+            restoreUAVs[i]->Release();
+    }
+
+    InDeviceContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
+
+    // Unbind RenderTargets
+    ID3D11RenderTargetView* nullRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
+
+    for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+    {
+        if (restoreRTVs[i])
+            restoreRTVs[i]->Release();
+    }
+
+    if (restoreDSV)
+        restoreDSV->Release();
+
     ID3D11DeviceContext4* dc;
     auto result = InDeviceContext->QueryInterface(IID_PPV_ARGS(&dc));
 
@@ -437,6 +496,29 @@ bool FSR2FeatureDx11on12_212::Evaluate(ID3D11DeviceContext* InDeviceContext, NVS
     _frameCount++;
     Dx12CommandQueue->Signal(Dx12Fence, _frameCount);
 
+    // restore compute shader resources
+    for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
+    }
+
+    InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);
+
     return evalResult;
 }
 

OptiScaler/upscalers/fsr31/FSR31Feature_Dx11.cpp

@@ -82,6 +82,7 @@ bool FSR31FeatureDx11::CopyTexture(ID3D11Resource* InResource, D3D11_TEXTURE2D_R
     if (result != S_OK)
         return false;
 
+    originalTexture->Release();
     originalTexture->GetDesc(&desc);
 
     if (desc.BindFlags == bindFlags)
@@ -163,24 +164,36 @@ bool FSR31FeatureDx11::Evaluate(ID3D11DeviceContext* DeviceContext, NVSDK_NGX_Pa
     {
         restoreSRVs[i] = nullptr;
         DeviceContext->CSGetShaderResources(i, 1, &restoreSRVs[i]);
+
+        if (restoreSRVs[i])
+            restoreSRVs[i]->Release();
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
     {
         restoreSamplerStates[i] = nullptr;
         DeviceContext->CSGetSamplers(i, 1, &restoreSamplerStates[i]);
+
+        if (restoreSamplerStates[i])
+            restoreSamplerStates[i]->Release();
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
     {
         restoreCBVs[i] = nullptr;
         DeviceContext->CSGetConstantBuffers(i, 1, &restoreCBVs[i]);
+
+        if (restoreCBVs[i])
+            restoreCBVs[i]->Release();
     }
 
     for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
     {
         restoreUAVs[i] = nullptr;
         DeviceContext->CSGetUnorderedAccessViews(i, 1, &restoreUAVs[i]);
+
+        if (restoreUAVs[i])
+            restoreUAVs[i]->Release();
     }
 
     DeviceContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
@@ -189,6 +202,15 @@ bool FSR31FeatureDx11::Evaluate(ID3D11DeviceContext* DeviceContext, NVSDK_NGX_Pa
     ID3D11RenderTargetView* nullRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
     DeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
 
+    for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+    {
+        if (restoreRTVs[i])
+            restoreRTVs[i]->Release();
+    }
+
+    if (restoreDSV)
+        restoreDSV->Release();
+
     Fsr31::FfxFsr3DispatchUpscaleDescription params {};
 
     if (Config::Instance()->FsrDebugView.value_or_default())
@@ -571,26 +593,22 @@ bool FSR31FeatureDx11::Evaluate(ID3D11DeviceContext* DeviceContext, NVSDK_NGX_Pa
     // restore compute shader resources
     for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
     {
-        if (restoreSRVs[i] != nullptr)
-            DeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
+        DeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
     {
-        if (restoreSamplerStates[i] != nullptr)
-            DeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
+        DeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
     {
-        if (restoreCBVs[i] != nullptr)
-            DeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
+        DeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
     }
 
     for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
     {
-        if (restoreUAVs[i] != nullptr)
-            DeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
+        DeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
     }
 
     DeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);

OptiScaler/upscalers/fsr31/FSR31Feature_Dx11On12.cpp

@@ -132,6 +132,65 @@ bool FSR31FeatureDx11on12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_
     if (Config::Instance()->DADepthIsLinear.value_for_config_ignore_default() == std::nullopt)
         Config::Instance()->DADepthIsLinear.set_volatile_value(false);
 
+    ID3D11ShaderResourceView* restoreSRVs[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = {};
+    ID3D11SamplerState* restoreSamplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = {};
+    ID3D11Buffer* restoreCBVs[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = {};
+    ID3D11UnorderedAccessView* restoreUAVs[D3D11_1_UAV_SLOT_COUNT] = {};
+    ID3D11RenderTargetView* restoreRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    ID3D11DepthStencilView* restoreDSV = nullptr;
+
+    // backup compute shader resources
+    for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
+    {
+        restoreSRVs[i] = nullptr;
+        InDeviceContext->CSGetShaderResources(i, 1, &restoreSRVs[i]);
+
+        if (restoreSRVs[i])
+            restoreSRVs[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
+    {
+        restoreSamplerStates[i] = nullptr;
+        InDeviceContext->CSGetSamplers(i, 1, &restoreSamplerStates[i]);
+
+        if (restoreSamplerStates[i])
+            restoreSamplerStates[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
+    {
+        restoreCBVs[i] = nullptr;
+        InDeviceContext->CSGetConstantBuffers(i, 1, &restoreCBVs[i]);
+
+        if (restoreCBVs[i])
+            restoreCBVs[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+    {
+        restoreUAVs[i] = nullptr;
+        InDeviceContext->CSGetUnorderedAccessViews(i, 1, &restoreUAVs[i]);
+
+        if (restoreUAVs[i])
+            restoreUAVs[i]->Release();
+    }
+
+    InDeviceContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
+
+    // Unbind RenderTargets
+    ID3D11RenderTargetView* nullRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
+
+    for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+    {
+        if (restoreRTVs[i])
+            restoreRTVs[i]->Release();
+    }
+
+    if (restoreDSV)
+        restoreDSV->Release();
+
     ID3D11DeviceContext4* dc;
     auto result = InDeviceContext->QueryInterface(IID_PPV_ARGS(&dc));
 
@@ -580,6 +639,29 @@ bool FSR31FeatureDx11on12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_
     _frameCount++;
     Dx12CommandQueue->Signal(Dx12Fence, _frameCount);
 
+    // restore compute shader resources
+    for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
+    }
+
+    InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);
+
     return evalResult;
 }
 

OptiScaler/upscalers/xess/XeSSFeature_Dx11.cpp

@@ -275,32 +275,61 @@ bool XeSSFeature_Dx11::Evaluate(ID3D11DeviceContext* DeviceContext, NVSDK_NGX_Pa
     ID3D11SamplerState* restoreSamplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = {};
     ID3D11Buffer* restoreCBVs[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = {};
     ID3D11UnorderedAccessView* restoreUAVs[D3D11_1_UAV_SLOT_COUNT] = {};
+    ID3D11RenderTargetView* restoreRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    ID3D11DepthStencilView* restoreDSV = nullptr;
 
     // backup compute shader resources
     for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
     {
         restoreSRVs[i] = nullptr;
         DeviceContext->CSGetShaderResources(i, 1, &restoreSRVs[i]);
+
+        if (restoreSRVs[i])
+            restoreSRVs[i]->Release();
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
     {
         restoreSamplerStates[i] = nullptr;
         DeviceContext->CSGetSamplers(i, 1, &restoreSamplerStates[i]);
+
+        if (restoreSamplerStates[i])
+            restoreSamplerStates[i]->Release();
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
     {
         restoreCBVs[i] = nullptr;
         DeviceContext->CSGetConstantBuffers(i, 1, &restoreCBVs[i]);
+
+        if (restoreCBVs[i])
+            restoreCBVs[i]->Release();
     }
 
     for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
     {
         restoreUAVs[i] = nullptr;
         DeviceContext->CSGetUnorderedAccessViews(i, 1, &restoreUAVs[i]);
+
+        if (restoreUAVs[i])
+            restoreUAVs[i]->Release();
     }
 
+    DeviceContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
+
+    // Unbind RenderTargets
+    ID3D11RenderTargetView* nullRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    DeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
+
+    for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+    {
+        if (restoreRTVs[i])
+            restoreRTVs[i]->Release();
+    }
+
+    if (restoreDSV)
+        restoreDSV->Release();
+
     if (State::Instance().xessDebug)
     {
         LOG_ERROR("xessDebug");
@@ -587,28 +616,26 @@ bool XeSSFeature_Dx11::Evaluate(ID3D11DeviceContext* DeviceContext, NVSDK_NGX_Pa
     // restore compute shader resources
     for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
     {
-        if (restoreSRVs[i] != nullptr)
-            DeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
+        DeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
     {
-        if (restoreSamplerStates[i] != nullptr)
-            DeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
+        DeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
     }
 
     for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
     {
-        if (restoreCBVs[i] != nullptr)
-            DeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
+        DeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
     }
 
     for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
     {
-        if (restoreUAVs[i] != nullptr)
-            DeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
+        DeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
     }
 
+    DeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);
+
     _frameCount++;
 
     return true;

OptiScaler/upscalers/xess/XeSSFeature_Dx11on12.cpp

@@ -127,6 +127,65 @@ bool XeSSFeatureDx11on12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_N
     if (Config::Instance()->DADepthIsLinear.value_for_config_ignore_default() == std::nullopt)
         Config::Instance()->DADepthIsLinear.set_volatile_value(false);
 
+    ID3D11ShaderResourceView* restoreSRVs[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = {};
+    ID3D11SamplerState* restoreSamplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = {};
+    ID3D11Buffer* restoreCBVs[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = {};
+    ID3D11UnorderedAccessView* restoreUAVs[D3D11_1_UAV_SLOT_COUNT] = {};
+    ID3D11RenderTargetView* restoreRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    ID3D11DepthStencilView* restoreDSV = nullptr;
+
+    // backup compute shader resources
+    for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
+    {
+        restoreSRVs[i] = nullptr;
+        InDeviceContext->CSGetShaderResources(i, 1, &restoreSRVs[i]);
+
+        if (restoreSRVs[i])
+            restoreSRVs[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
+    {
+        restoreSamplerStates[i] = nullptr;
+        InDeviceContext->CSGetSamplers(i, 1, &restoreSamplerStates[i]);
+
+        if (restoreSamplerStates[i])
+            restoreSamplerStates[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
+    {
+        restoreCBVs[i] = nullptr;
+        InDeviceContext->CSGetConstantBuffers(i, 1, &restoreCBVs[i]);
+
+        if (restoreCBVs[i])
+            restoreCBVs[i]->Release();
+    }
+
+    for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+    {
+        restoreUAVs[i] = nullptr;
+        InDeviceContext->CSGetUnorderedAccessViews(i, 1, &restoreUAVs[i]);
+
+        if (restoreUAVs[i])
+            restoreUAVs[i]->Release();
+    }
+
+    InDeviceContext->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, &restoreDSV);
+
+    // Unbind RenderTargets
+    ID3D11RenderTargetView* nullRTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {};
+    InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, nullRTVs, nullptr);
+
+    for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+    {
+        if (restoreRTVs[i])
+            restoreRTVs[i]->Release();
+    }
+
+    if (restoreDSV)
+        restoreDSV->Release();
+
     ID3D11DeviceContext4* dc;
     auto result = InDeviceContext->QueryInterface(IID_PPV_ARGS(&dc));
 
@@ -440,6 +499,29 @@ bool XeSSFeatureDx11on12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_N
     _frameCount++;
     Dx12CommandQueue->Signal(Dx12Fence, _frameCount);
 
+    // restore compute shader resources
+    for (UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetShaderResources(i, 1, &restoreSRVs[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetSamplers(i, 1, &restoreSamplerStates[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetConstantBuffers(i, 1, &restoreCBVs[i]);
+    }
+
+    for (UINT i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+    {
+        InDeviceContext->CSSetUnorderedAccessViews(i, 1, &restoreUAVs[i], 0);
+    }
+
+    InDeviceContext->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, restoreRTVs, restoreDSV);
+
     return evalResult;
 }