D3D: Implement logic op support

Source/Core/VideoBackends/D3D/D3DBase.cpp

@@ -33,6 +33,7 @@ int d3d_dll_ref = 0;
 namespace D3D
 {
 ID3D11Device* device = nullptr;
+ID3D11Device1* device1 = nullptr;
 ID3D11DeviceContext* context = nullptr;
 static IDXGISwapChain1* swapchain = nullptr;
 static ID3D11Debug* debug = nullptr;
@@ -307,9 +308,9 @@ HRESULT Create(HWND wnd)
   swap_chain_desc.Stereo =
       g_ActiveConfig.iStereoMode == STEREO_QUADBUFFER || factory->IsWindowedStereoEnabled();
 
-#if defined(_DEBUG) || defined(DEBUGFAST)
   // Creating debug devices can sometimes fail if the user doesn't have the correct
   // version of the DirectX SDK. If it does, simply fallback to a non-debug device.
+  if (g_Config.bEnableValidationLayer)
   {
     hr = PD3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr, D3D11_CREATE_DEVICE_DEBUG,
                             supported_feature_levels, NUM_SUPPORTED_FEATURE_LEVELS,
@@ -335,8 +336,7 @@ HRESULT Create(HWND wnd)
     }
   }
 
-  if (FAILED(hr))
-#endif
+  if (!g_Config.bEnableValidationLayer || FAILED(hr))
   {
     hr = PD3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr, 0, supported_feature_levels,
                             NUM_SUPPORTED_FEATURE_LEVELS, D3D11_SDK_VERSION, &device, &featlevel,
@@ -378,6 +378,10 @@ HRESULT Create(HWND wnd)
     return E_FAIL;
   }
 
+  hr = device->QueryInterface<ID3D11Device1>(&device1);
+  if (FAILED(hr))
+    WARN_LOG(VIDEO, "Missing Direct3D 11.1 support. Logical operations will not be supported.");
+
   // prevent DXGI from responding to Alt+Enter, unfortunately DXGI_MWA_NO_ALT_ENTER
   // does not work so we disable all monitoring of window messages. However this
   // may make it more difficult for DXGI to handle display mode changes.
@@ -440,6 +444,7 @@ void Close()
   context->Flush();  // immediately destroy device objects
 
   SAFE_RELEASE(context);
+  SAFE_RELEASE(device1);
   ULONG references = device->Release();
 
 #if defined(_DEBUG) || defined(DEBUGFAST)

Source/Core/VideoBackends/D3D/D3DBase.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <d3d11.h>
+#include <d3d11_1.h>
 #include <d3dcompiler.h>
 #include <dxgi1_2.h>
 #include <vector>
@@ -56,6 +57,7 @@ HRESULT Create(HWND wnd);
 void Close();
 
 extern ID3D11Device* device;
+extern ID3D11Device1* device1;
 extern ID3D11DeviceContext* context;
 extern HWND hWnd;
 extern bool bFrameInProgress;

Source/Core/VideoBackends/D3D/D3DState.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <array>
 
 #include "Common/BitSet.h"
 #include "Common/CommonTypes.h"
@@ -351,72 +352,82 @@ ID3D11SamplerState* StateCache::Get(SamplerState state)
   return res;
 }
 
-ID3D11BlendState* StateCache::Get(BlendState state)
+ID3D11BlendState* StateCache::Get(BlendingState state)
 {
-  if (!state.blend_enable)
+  auto it = m_blend.find(state.hex);
+  if (it != m_blend.end())
+    return it->second;
+
+  if (state.logicopenable && D3D::device1)
   {
-    state.src_blend = D3D11_BLEND_ONE;
-    state.dst_blend = D3D11_BLEND_ZERO;
-    state.blend_op = D3D11_BLEND_OP_ADD;
-    state.use_dst_alpha = false;
+    D3D11_BLEND_DESC1 desc = {};
+    D3D11_RENDER_TARGET_BLEND_DESC1& tdesc = desc.RenderTarget[0];
+    if (state.colorupdate)
+      tdesc.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_RED | D3D11_COLOR_WRITE_ENABLE_GREEN |
+                                    D3D11_COLOR_WRITE_ENABLE_BLUE;
+    else
+      tdesc.RenderTargetWriteMask = 0;
+    if (state.alphaupdate)
+      tdesc.RenderTargetWriteMask |= D3D11_COLOR_WRITE_ENABLE_ALPHA;
+
+    static constexpr std::array<D3D11_LOGIC_OP, 16> logic_ops = {
+        {D3D11_LOGIC_OP_CLEAR, D3D11_LOGIC_OP_AND, D3D11_LOGIC_OP_AND_REVERSE, D3D11_LOGIC_OP_COPY,
+         D3D11_LOGIC_OP_AND_INVERTED, D3D11_LOGIC_OP_NOOP, D3D11_LOGIC_OP_XOR, D3D11_LOGIC_OP_OR,
+         D3D11_LOGIC_OP_NOR, D3D11_LOGIC_OP_EQUIV, D3D11_LOGIC_OP_INVERT, D3D11_LOGIC_OP_OR_REVERSE,
+         D3D11_LOGIC_OP_COPY_INVERTED, D3D11_LOGIC_OP_OR_INVERTED, D3D11_LOGIC_OP_NAND,
+         D3D11_LOGIC_OP_SET}};
+    tdesc.LogicOpEnable = TRUE;
+    tdesc.LogicOp = logic_ops[state.logicmode];
+
+    ID3D11BlendState1* res;
+    HRESULT hr = D3D::device1->CreateBlendState1(&desc, &res);
+    if (SUCCEEDED(hr))
+    {
+      D3D::SetDebugObjectName(res, "blend state used to emulate the GX pipeline");
+      m_blend.emplace(state.hex, res);
+      return res;
+    }
   }
 
-  auto it = m_blend.find(state.packed);
+  D3D11_BLEND_DESC desc = {};
+  desc.AlphaToCoverageEnable = FALSE;
+  desc.IndependentBlendEnable = FALSE;
 
-  if (it != m_blend.end())
-    return it->second;
+  D3D11_RENDER_TARGET_BLEND_DESC& tdesc = desc.RenderTarget[0];
+  tdesc.BlendEnable = state.blendenable;
 
-  D3D11_BLEND_DESC blenddc = CD3D11_BLEND_DESC(CD3D11_DEFAULT());
-
-  blenddc.AlphaToCoverageEnable = FALSE;
-  blenddc.IndependentBlendEnable = FALSE;
-  blenddc.RenderTarget[0].BlendEnable = state.blend_enable;
-  blenddc.RenderTarget[0].RenderTargetWriteMask = (u32)state.write_mask;
-  blenddc.RenderTarget[0].SrcBlend = state.src_blend;
-  blenddc.RenderTarget[0].DestBlend = state.dst_blend;
-  blenddc.RenderTarget[0].BlendOp = state.blend_op;
-  blenddc.RenderTarget[0].SrcBlendAlpha = state.src_blend;
-  blenddc.RenderTarget[0].DestBlendAlpha = state.dst_blend;
-  blenddc.RenderTarget[0].BlendOpAlpha = state.blend_op;
-
-  if (blenddc.RenderTarget[0].SrcBlend == D3D11_BLEND_SRC_COLOR)
-    blenddc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC1_ALPHA;
-  else if (blenddc.RenderTarget[0].SrcBlend == D3D11_BLEND_INV_SRC_COLOR)
-    blenddc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
-  else if (blenddc.RenderTarget[0].SrcBlend == D3D11_BLEND_DEST_COLOR)
-    blenddc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_DEST_ALPHA;
-  else if (blenddc.RenderTarget[0].SrcBlend == D3D11_BLEND_INV_DEST_COLOR)
-    blenddc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_INV_DEST_ALPHA;
-  else
-    blenddc.RenderTarget[0].SrcBlendAlpha = blenddc.RenderTarget[0].SrcBlend;
-
-  if (blenddc.RenderTarget[0].DestBlend == D3D11_BLEND_SRC_COLOR)
-    blenddc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_SRC1_ALPHA;
-  else if (blenddc.RenderTarget[0].DestBlend == D3D11_BLEND_INV_SRC_COLOR)
-    blenddc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
-  else if (blenddc.RenderTarget[0].DestBlend == D3D11_BLEND_DEST_COLOR)
-    blenddc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_DEST_ALPHA;
-  else if (blenddc.RenderTarget[0].DestBlend == D3D11_BLEND_INV_DEST_COLOR)
-    blenddc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_DEST_ALPHA;
+  if (state.colorupdate)
+    tdesc.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_RED | D3D11_COLOR_WRITE_ENABLE_GREEN |
+                                  D3D11_COLOR_WRITE_ENABLE_BLUE;
   else
-    blenddc.RenderTarget[0].DestBlendAlpha = blenddc.RenderTarget[0].DestBlend;
-
-  if (state.use_dst_alpha)
-  {
-    blenddc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
-    blenddc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
-    blenddc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
-  }
+    tdesc.RenderTargetWriteMask = 0;
+  if (state.alphaupdate)
+    tdesc.RenderTargetWriteMask |= D3D11_COLOR_WRITE_ENABLE_ALPHA;
+
+  static constexpr std::array<D3D11_BLEND, 8> src_factors = {
+      {D3D11_BLEND_ZERO, D3D11_BLEND_ONE, D3D11_BLEND_DEST_COLOR, D3D11_BLEND_INV_DEST_COLOR,
+       D3D11_BLEND_SRC1_ALPHA, D3D11_BLEND_INV_SRC1_ALPHA, D3D11_BLEND_DEST_ALPHA,
+       D3D11_BLEND_INV_DEST_ALPHA}};
+  static constexpr std::array<D3D11_BLEND, 8> dst_factors = {
+      {D3D11_BLEND_ZERO, D3D11_BLEND_ONE, D3D11_BLEND_SRC_COLOR, D3D11_BLEND_INV_SRC_COLOR,
+       D3D11_BLEND_SRC1_ALPHA, D3D11_BLEND_INV_SRC1_ALPHA, D3D11_BLEND_DEST_ALPHA,
+       D3D11_BLEND_INV_DEST_ALPHA}};
+
+  tdesc.SrcBlend = src_factors[state.srcfactor];
+  tdesc.SrcBlendAlpha = src_factors[state.srcfactoralpha];
+  tdesc.DestBlend = dst_factors[state.dstfactor];
+  tdesc.DestBlendAlpha = dst_factors[state.dstfactoralpha];
+  tdesc.BlendOp = state.subtract ? D3D11_BLEND_OP_REV_SUBTRACT : D3D11_BLEND_OP_ADD;
+  tdesc.BlendOpAlpha = state.subtractAlpha ? D3D11_BLEND_OP_REV_SUBTRACT : D3D11_BLEND_OP_ADD;
 
   ID3D11BlendState* res = nullptr;
 
-  HRESULT hr = D3D::device->CreateBlendState(&blenddc, &res);
+  HRESULT hr = D3D::device->CreateBlendState(&desc, &res);
   if (FAILED(hr))
     PanicAlert("Failed to create blend state at %s %d\n", __FILE__, __LINE__);
 
   D3D::SetDebugObjectName(res, "blend state used to emulate the GX pipeline");
-  m_blend.emplace(state.packed, res);
-
+  m_blend.emplace(state.hex, res);
   return res;
 }
 

Source/Core/VideoBackends/D3D/D3DState.h

@@ -12,7 +12,7 @@
 #include "Common/BitField.h"
 #include "Common/CommonTypes.h"
 #include "VideoBackends/D3D/D3DBase.h"
-#include "VideoCommon/BPMemory.h"
+#include "VideoCommon/RenderState.h"
 
 struct ID3D11BlendState;
 struct ID3D11DepthStencilState;
@@ -27,18 +27,6 @@ union RasterizerState
   u32 packed;
 };
 
-union BlendState
-{
-  BitField<0, 1, u32> blend_enable;
-  BitField<1, 3, D3D11_BLEND_OP> blend_op;
-  BitField<4, 4, u32> write_mask;
-  BitField<8, 5, D3D11_BLEND> src_blend;
-  BitField<13, 5, D3D11_BLEND> dst_blend;
-  BitField<18, 1, u32> use_dst_alpha;
-
-  u32 packed;
-};
-
 union SamplerState
 {
   BitField<0, 3, u64> min_filter;
@@ -59,7 +47,7 @@ class StateCache
   // Get existing or create new render state.
   // Returned objects is owned by the cache and does not need to be released.
   ID3D11SamplerState* Get(SamplerState state);
-  ID3D11BlendState* Get(BlendState state);
+  ID3D11BlendState* Get(BlendingState state);
   ID3D11RasterizerState* Get(RasterizerState state);
   ID3D11DepthStencilState* Get(ZMode state);
 

Source/Core/VideoBackends/D3D/DXTexture.cpp

@@ -181,9 +181,7 @@ void DXTexture::CopyRectangleFromTexture(const AbstractTexture* source,
                          VertexShaderCache::GetSimpleInputLayout(),
                          GeometryShaderCache::GetCopyGeometryShader(), 1.0, 0);
 
-  D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(),
-                                   FramebufferManager::GetEFBDepthTexture()->GetDSV());
-
+  FramebufferManager::BindEFBRenderTarget();
   g_renderer->RestoreAPIState();
 }
 

Source/Core/VideoBackends/D3D/FramebufferManager.cpp

@@ -5,6 +5,7 @@
 #include "VideoBackends/D3D/FramebufferManager.h"
 
 #include <memory>
+#include <utility>
 
 #include "Common/CommonTypes.h"
 #include "Core/HW/Memmap.h"
@@ -21,6 +22,7 @@
 namespace DX11
 {
 static XFBEncoder s_xfbEncoder;
+static bool s_integer_efb_render_target = false;
 
 FramebufferManager::Efb FramebufferManager::m_efb;
 unsigned int FramebufferManager::m_target_width;
@@ -30,6 +32,7 @@ D3DTexture2D*& FramebufferManager::GetEFBColorTexture()
 {
   return m_efb.color_tex;
 }
+
 D3DTexture2D*& FramebufferManager::GetEFBColorReadTexture()
 {
   return m_efb.color_read_texture;
@@ -86,8 +89,7 @@ D3DTexture2D*& FramebufferManager::GetResolvedEFBDepthTexture()
         PixelShaderCache::GetDepthResolveProgram(), VertexShaderCache::GetSimpleVertexShader(),
         VertexShaderCache::GetSimpleInputLayout(), GeometryShaderCache::GetCopyGeometryShader());
 
-    D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(),
-                                     FramebufferManager::GetEFBDepthTexture()->GetDSV());
+    BindEFBRenderTarget();
     g_renderer->RestoreAPIState();
 
     return m_efb.resolved_depth_tex;
@@ -98,6 +100,33 @@ D3DTexture2D*& FramebufferManager::GetResolvedEFBDepthTexture()
   }
 }
 
+void FramebufferManager::SwapReinterpretTexture()
+{
+  std::swap(m_efb.color_tex, m_efb.color_temp_tex);
+  std::swap(m_efb.color_int_rtv, m_efb.color_temp_int_rtv);
+}
+
+void FramebufferManager::SetIntegerEFBRenderTarget(bool enabled)
+{
+  if (s_integer_efb_render_target == enabled)
+    return;
+
+  // We only use UINT render targets for logic ops, which is only supported with D3D11.1.
+  if (!D3D::device1)
+    return;
+
+  s_integer_efb_render_target = enabled;
+  BindEFBRenderTarget();
+}
+
+void FramebufferManager::BindEFBRenderTarget(bool bind_depth)
+{
+  ID3D11RenderTargetView* rtv =
+      s_integer_efb_render_target ? m_efb.color_int_rtv : m_efb.color_tex->GetRTV();
+  ID3D11DepthStencilView* dsv = bind_depth ? m_efb.depth_tex->GetDSV() : nullptr;
+  D3D::context->OMSetRenderTargets(1, &rtv, dsv);
+}
+
 FramebufferManager::FramebufferManager(int target_width, int target_height)
 {
   m_target_width = static_cast<unsigned int>(std::max(target_width, 1));
@@ -114,7 +143,7 @@ FramebufferManager::FramebufferManager(int target_width, int target_height)
 
   // EFB color texture - primary render target
   texdesc =
-      CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, m_target_width, m_target_height,
+      CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_TYPELESS, m_target_width, m_target_height,
                             m_efb.slices, 1, D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET,
                             D3D11_USAGE_DEFAULT, 0, sample_desc.Count, sample_desc.Quality);
   hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
@@ -124,14 +153,15 @@ FramebufferManager::FramebufferManager(int target_width, int target_height)
       buf, (D3D11_BIND_FLAG)(D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET),
       DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM,
       (sample_desc.Count > 1));
+
   SAFE_RELEASE(buf);
   D3D::SetDebugObjectName(m_efb.color_tex->GetTex(), "EFB color texture");
   D3D::SetDebugObjectName(m_efb.color_tex->GetSRV(), "EFB color texture shader resource view");
   D3D::SetDebugObjectName(m_efb.color_tex->GetRTV(), "EFB color texture render target view");
 
   // Temporary EFB color texture - used in ReinterpretPixelData
   texdesc =
-      CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, m_target_width, m_target_height,
+      CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_TYPELESS, m_target_width, m_target_height,
                             m_efb.slices, 1, D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET,
                             D3D11_USAGE_DEFAULT, 0, sample_desc.Count, sample_desc.Quality);
   hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
@@ -148,6 +178,19 @@ FramebufferManager::FramebufferManager(int target_width, int target_height)
   D3D::SetDebugObjectName(m_efb.color_temp_tex->GetRTV(),
                           "EFB color temp texture render target view");
 
+  // Integer render targets for EFB, used for logic op
+  CD3D11_RENDER_TARGET_VIEW_DESC int_rtv_desc(m_efb.color_tex->GetTex(),
+                                              g_ActiveConfig.iMultisamples > 1 ?
+                                                  D3D11_RTV_DIMENSION_TEXTURE2DMS :
+                                                  D3D11_RTV_DIMENSION_TEXTURE2D,
+                                              DXGI_FORMAT_R8G8B8A8_UINT);
+  hr = D3D::device->CreateRenderTargetView(m_efb.color_tex->GetTex(), &int_rtv_desc,
+                                           &m_efb.color_int_rtv);
+  CHECK(hr == S_OK, "create EFB integer RTV(hr=%#x)", hr);
+  hr = D3D::device->CreateRenderTargetView(m_efb.color_temp_tex->GetTex(), &int_rtv_desc,
+                                           &m_efb.color_temp_int_rtv);
+  CHECK(hr == S_OK, "create EFB integer RTV(hr=%#x)", hr);
+
   // Render buffer for AccessEFB (color data)
   texdesc = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_R8G8B8A8_UNORM, 1, 1, 1, 1, D3D11_BIND_RENDER_TARGET);
   hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &buf);
@@ -241,14 +284,17 @@ FramebufferManager::FramebufferManager(int target_width, int target_height)
   }
 
   s_xfbEncoder.Init();
+  s_integer_efb_render_target = false;
 }
 
 FramebufferManager::~FramebufferManager()
 {
   s_xfbEncoder.Shutdown();
 
   SAFE_RELEASE(m_efb.color_tex);
+  SAFE_RELEASE(m_efb.color_int_rtv);
   SAFE_RELEASE(m_efb.color_temp_tex);
+  SAFE_RELEASE(m_efb.color_temp_int_rtv);
   SAFE_RELEASE(m_efb.color_staging_buf);
   SAFE_RELEASE(m_efb.color_read_texture);
   SAFE_RELEASE(m_efb.resolved_color_tex);
@@ -308,9 +354,7 @@ void XFBSource::CopyEFB(float Gamma)
       VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout(),
       GeometryShaderCache::GetCopyGeometryShader(), Gamma);
 
-  D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(),
-                                   FramebufferManager::GetEFBDepthTexture()->GetDSV());
-
+  FramebufferManager::BindEFBRenderTarget();
   g_renderer->RestoreAPIState();
 }