Merge pull request #6399 from stenzek/videocommon-shader-cache

VideoCommon Shader (Pipeline) Cache

Source/Core/Common/GL/GLUtil.cpp

@@ -11,12 +11,14 @@
 
 std::unique_ptr<cInterfaceBase> GLInterface;
 
+namespace GLUtil
+{
 void InitInterface()
 {
   GLInterface = HostGL_CreateGLInterface();
 }
 
-GLuint OpenGL_CompileProgram(const std::string& vertexShader, const std::string& fragmentShader)
+GLuint CompileProgram(const std::string& vertexShader, const std::string& fragmentShader)
 {
   // generate objects
   GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
@@ -100,3 +102,27 @@ GLuint OpenGL_CompileProgram(const std::string& vertexShader, const std::string&
 
   return programID;
 }
+
+void EnablePrimitiveRestart()
+{
+  constexpr GLuint PRIMITIVE_RESTART_INDEX = 65535;
+
+  if (GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGLES3)
+  {
+    glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
+  }
+  else
+  {
+    if (GLExtensions::Version() >= 310)
+    {
+      glEnable(GL_PRIMITIVE_RESTART);
+      glPrimitiveRestartIndex(PRIMITIVE_RESTART_INDEX);
+    }
+    else
+    {
+      glEnableClientState(GL_PRIMITIVE_RESTART_NV);
+      glPrimitiveRestartIndexNV(PRIMITIVE_RESTART_INDEX);
+    }
+  }
+}
+}

Source/Core/Common/GL/GLUtil.h

@@ -8,12 +8,9 @@
 
 #include "Common/GL/GLExtensions/GLExtensions.h"
 
-#ifndef _WIN32
-
-#include <sys/types.h>
-
-#endif
+namespace GLUtil
+{
 void InitInterface();
-
-// Helpers
-GLuint OpenGL_CompileProgram(const std::string& vertexShader, const std::string& fragmentShader);
+GLuint CompileProgram(const std::string& vertexShader, const std::string& fragmentShader);
+void EnablePrimitiveRestart();
+}

Source/Core/Core/Analytics.cpp

@@ -180,13 +180,16 @@ void DolphinAnalytics::MakeBaseBuilder()
 
 static const char* GetUbershaderMode(const VideoConfig& video_config)
 {
-  if (video_config.bDisableSpecializedShaders)
+  switch (video_config.iUberShaderMode)
+  {
+  case UberShaderMode::Exclusive:
     return "exclusive";
-
-  if (video_config.bBackgroundShaderCompiling)
+  case UberShaderMode::Hybrid:
     return "hybrid";
-
-  return "disabled";
+  case UberShaderMode::Disabled:
+  default:
+    return "disabled";
+  }
 }
 
 void DolphinAnalytics::MakePerGameBuilder()

Source/Core/Core/Config/GraphicsSettings.cpp

@@ -76,12 +76,10 @@ const ConfigInfo<bool> GFX_BACKEND_MULTITHREADING{
 const ConfigInfo<int> GFX_COMMAND_BUFFER_EXECUTE_INTERVAL{
     {System::GFX, "Settings", "CommandBufferExecuteInterval"}, 100};
 const ConfigInfo<bool> GFX_SHADER_CACHE{{System::GFX, "Settings", "ShaderCache"}, true};
-const ConfigInfo<bool> GFX_BACKGROUND_SHADER_COMPILING{
-    {System::GFX, "Settings", "BackgroundShaderCompiling"}, false};
-const ConfigInfo<bool> GFX_DISABLE_SPECIALIZED_SHADERS{
-    {System::GFX, "Settings", "DisableSpecializedShaders"}, false};
-const ConfigInfo<bool> GFX_PRECOMPILE_UBER_SHADERS{
-    {System::GFX, "Settings", "PrecompileUberShaders"}, true};
+const ConfigInfo<bool> GFX_WAIT_FOR_SHADERS_BEFORE_STARTING{
+    {System::GFX, "Settings", "WaitForShadersBeforeStarting"}, false};
+const ConfigInfo<int> GFX_UBERSHADER_MODE{{System::GFX, "Settings", "UberShaderMode"},
+                                          static_cast<int>(UberShaderMode::Disabled)};
 const ConfigInfo<int> GFX_SHADER_COMPILER_THREADS{
     {System::GFX, "Settings", "ShaderCompilerThreads"}, 1};
 const ConfigInfo<int> GFX_SHADER_PRECOMPILER_THREADS{

Source/Core/Core/Config/GraphicsSettings.h

@@ -59,9 +59,8 @@ extern const ConfigInfo<bool> GFX_ENABLE_VALIDATION_LAYER;
 extern const ConfigInfo<bool> GFX_BACKEND_MULTITHREADING;
 extern const ConfigInfo<int> GFX_COMMAND_BUFFER_EXECUTE_INTERVAL;
 extern const ConfigInfo<bool> GFX_SHADER_CACHE;
-extern const ConfigInfo<bool> GFX_BACKGROUND_SHADER_COMPILING;
-extern const ConfigInfo<bool> GFX_DISABLE_SPECIALIZED_SHADERS;
-extern const ConfigInfo<bool> GFX_PRECOMPILE_UBER_SHADERS;
+extern const ConfigInfo<bool> GFX_WAIT_FOR_SHADERS_BEFORE_STARTING;
+extern const ConfigInfo<int> GFX_UBERSHADER_MODE;
 extern const ConfigInfo<int> GFX_SHADER_COMPILER_THREADS;
 extern const ConfigInfo<int> GFX_SHADER_PRECOMPILER_THREADS;
 

Source/Core/Core/ConfigLoaders/IsSettingSaveable.cpp

@@ -46,10 +46,8 @@ bool IsSettingSaveable(const Config::ConfigLocation& config_location)
       Config::GFX_DISABLE_FOG.location, Config::GFX_BORDERLESS_FULLSCREEN.location,
       Config::GFX_ENABLE_VALIDATION_LAYER.location, Config::GFX_BACKEND_MULTITHREADING.location,
       Config::GFX_COMMAND_BUFFER_EXECUTE_INTERVAL.location, Config::GFX_SHADER_CACHE.location,
-      Config::GFX_BACKGROUND_SHADER_COMPILING.location,
-      Config::GFX_DISABLE_SPECIALIZED_SHADERS.location,
-      Config::GFX_PRECOMPILE_UBER_SHADERS.location, Config::GFX_SHADER_COMPILER_THREADS.location,
-      Config::GFX_SHADER_PRECOMPILER_THREADS.location,
+      Config::GFX_WAIT_FOR_SHADERS_BEFORE_STARTING.location, Config::GFX_UBERSHADER_MODE.location,
+      Config::GFX_SHADER_COMPILER_THREADS.location, Config::GFX_SHADER_PRECOMPILER_THREADS.location,
 
       Config::GFX_SW_ZCOMPLOC.location, Config::GFX_SW_ZFREEZE.location,
       Config::GFX_SW_DUMP_OBJECTS.location, Config::GFX_SW_DUMP_TEV_STAGES.location,

Source/Core/DolphinQt2/Config/Graphics/EnhancementsWidget.cpp

@@ -63,9 +63,8 @@ void EnhancementsWidget::CreateWidgets()
   m_af_combo = new GraphicsChoice({tr("1x"), tr("2x"), tr("4x"), tr("8x"), tr("16x")},
                                   Config::GFX_ENHANCE_MAX_ANISOTROPY);
 
-  m_ubershader_combo = new QComboBox;
-  for (const auto& option : {tr("Disabled"), tr("Hybrid"), tr("Exclusive")})
-    m_ubershader_combo->addItem(option);
+  m_ubershader_combo = new GraphicsChoice({tr("Disabled"), tr("Hybrid"), tr("Exclusive")},
+                                          Config::GFX_UBERSHADER_MODE);
 
   m_pp_effect = new QComboBox();
   m_configure_pp_effect = new QPushButton(tr("Configure"));
@@ -131,9 +130,6 @@ void EnhancementsWidget::ConnectWidgets()
 {
   connect(m_aa_combo, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
           [this](int) { SaveSettings(); });
-  connect(m_ubershader_combo,
-          static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
-          [this](int) { SaveSettings(); });
   connect(m_pp_effect, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
           [this](int) { SaveSettings(); });
   connect(m_3d_mode, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
@@ -156,13 +152,6 @@ void EnhancementsWidget::LoadSettings()
       QString::fromStdString(std::to_string(aa_selection) + "x " + (ssaa ? "SSAA" : "MSAA")));
   m_aa_combo->setEnabled(m_aa_combo->count() > 1);
 
-  if (Config::GetBase(Config::GFX_DISABLE_SPECIALIZED_SHADERS))
-    m_ubershader_combo->setCurrentIndex(2);
-  else if (Config::GetBase(Config::GFX_BACKGROUND_SHADER_COMPILING))
-    m_ubershader_combo->setCurrentIndex(1);
-  else
-    m_ubershader_combo->setCurrentIndex(0);
-
   // Post Processing Shader
   std::vector<std::string> shaders =
       g_Config.stereo_mode == StereoMode::Anaglyph ?
@@ -220,10 +209,6 @@ void EnhancementsWidget::SaveSettings()
 
   Config::SetBaseOrCurrent(Config::GFX_SSAA, is_ssaa);
 
-  int us_value = m_ubershader_combo->currentIndex();
-  Config::SetBaseOrCurrent(Config::GFX_BACKGROUND_SHADER_COMPILING, us_value == 1);
-  Config::SetBaseOrCurrent(Config::GFX_DISABLE_SPECIALIZED_SHADERS, us_value == 2);
-
   Config::SetBaseOrCurrent(Config::GFX_ENHANCE_POST_SHADER,
                            m_pp_effect->currentText().toStdString());
 

Source/Core/DolphinQt2/Config/Graphics/GeneralWidget.cpp

@@ -87,6 +87,8 @@ void GeneralWidget::CreateWidgets()
   m_keep_window_top = new QCheckBox(tr("Keep Window on Top"));
   m_hide_cursor = new QCheckBox(tr("Hide Mouse Cursor"));
   m_render_main_window = new QCheckBox(tr("Render to Main Window"));
+  m_wait_for_shaders = new GraphicsBool(tr("Immediately Compile Shaders"),
+                                        Config::GFX_WAIT_FOR_SHADERS_BEFORE_STARTING);
 
   m_options_box->setLayout(m_options_layout);
 
@@ -101,6 +103,7 @@ void GeneralWidget::CreateWidgets()
 
   m_options_layout->addWidget(m_hide_cursor, 3, 0);
   m_options_layout->addWidget(m_render_main_window, 3, 1);
+  m_options_layout->addWidget(m_wait_for_shaders, 4, 0);
 
   main_layout->addWidget(m_video_box);
   main_layout->addWidget(m_options_box);
@@ -265,6 +268,12 @@ void GeneralWidget::AddDescriptions()
   static const char* TR_SHOW_NETPLAY_MESSAGES_DESCRIPTION =
       QT_TR_NOOP("When playing on NetPlay, show chat messages, buffer changes and "
                  "desync alerts.\n\nIf unsure, leave this unchecked.");
+  static const char* TR_WAIT_FOR_SHADERS_DESCRIPTION = QT_TR_NOOP(
+      "Waits for all shaders to finish compiling before starting a game. Enabling this "
+      "option may reduce stuttering or hitching for a short time after the game is "
+      "started, at the cost of a longer delay before the game starts.\n\nFor systems "
+      "with two or fewer cores, it is recommended to enable this option, as a large "
+      "shader queue may reduce frame rates. Otherwise, if unsure, leave this unchecked.");
 
   AddDescription(m_backend_combo, TR_BACKEND_DESCRIPTION);
 #ifdef _WIN32
@@ -282,6 +291,7 @@ void GeneralWidget::AddDescriptions()
   AddDescription(m_show_messages, TR_SHOW_FPS_DESCRIPTION);
   AddDescription(m_keep_window_top, TR_KEEP_WINDOW_ON_TOP_DESCRIPTION);
   AddDescription(m_show_messages, TR_SHOW_NETPLAY_MESSAGES_DESCRIPTION);
+  AddDescription(m_wait_for_shaders, TR_WAIT_FOR_SHADERS_DESCRIPTION);
 }
 void GeneralWidget::OnBackendChanged(const QString& backend_name)
 {

Source/Core/DolphinQt2/Config/Graphics/GeneralWidget.h

@@ -52,6 +52,7 @@ private:
   QCheckBox* m_keep_window_top;
   QCheckBox* m_hide_cursor;
   QCheckBox* m_render_main_window;
+  QCheckBox* m_wait_for_shaders;
 
   X11Utils::XRRConfiguration* m_xrr_config;
 };

Source/Core/DolphinWX/VideoConfigDiag.cpp

@@ -317,6 +317,12 @@ static wxString ubershader_desc =
                 "stuttering. Balances performance and smoothness.\n\n"
                 "Exclusive: Ubershaders will always be used. Only recommended for high-end "
                 "systems.");
+static wxString wait_for_shaders_desc =
+    wxTRANSLATE("Waits for all shaders to finish compiling before starting a game. Enabling this "
+                "option may reduce stuttering or hitching for a short time after the game is "
+                "started, at the cost of a longer delay before the game starts.\n\nFor systems "
+                "with two or fewer cores, it is recommended to enable this option, as a large "
+                "shader queue may reduce frame rates. Otherwise, if unsure, leave this unchecked.");
 
 VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string& title)
     : wxDialog(parent, wxID_ANY, wxString::Format(_("Dolphin %s Graphics Configuration"),
@@ -442,6 +448,10 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string& title)
                                         wxGetTranslation(backend_multithreading_desc),
                                         Config::GFX_BACKEND_MULTITHREADING));
         }
+
+        szr_other->Add(CreateCheckBox(page_general, _("Immediately Compile Shaders"),
+                                      wxGetTranslation(wait_for_shaders_desc),
+                                      Config::GFX_WAIT_FOR_SHADERS_BEFORE_STARTING));
       }
 
       wxStaticBoxSizer* const group_basic =
@@ -534,24 +544,13 @@ VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string& title)
     // ubershaders
     {
       const std::array<wxString, 3> mode_choices = {{_("Disabled"), _("Hybrid"), _("Exclusive")}};
-
-      wxChoice* const choice_mode =
-          new wxChoice(page_enh, wxID_ANY, wxDefaultPosition, wxDefaultSize,
-                       static_cast<int>(mode_choices.size()), mode_choices.data());
-      RegisterControl(choice_mode, wxGetTranslation(ubershader_desc));
       szr_enh->Add(new wxStaticText(page_enh, wxID_ANY, _("Ubershaders:")), wxGBPosition(row, 0),
                    wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
-      szr_enh->Add(choice_mode, wxGBPosition(row, 1), span2, wxALIGN_CENTER_VERTICAL);
+      szr_enh->Add(CreateChoice(page_enh, Config::GFX_UBERSHADER_MODE,
+                                wxGetTranslation(ubershader_desc), mode_choices.size(),
+                                mode_choices.data()),
+                   wxGBPosition(row, 1), span2, wxALIGN_CENTER_VERTICAL);
       row += 1;
-
-      // Determine ubershader mode
-      choice_mode->Bind(wxEVT_CHOICE, &VideoConfigDiag::OnUberShaderModeChanged, this);
-      if (Config::GetBase(Config::GFX_DISABLE_SPECIALIZED_SHADERS))
-        choice_mode->SetSelection(2);
-      else if (Config::GetBase(Config::GFX_BACKGROUND_SHADER_COMPILING))
-        choice_mode->SetSelection(1);
-      else
-        choice_mode->SetSelection(0);
     }
 
     // postproc shader
@@ -1290,13 +1289,3 @@ void VideoConfigDiag::OnAAChanged(wxCommandEvent& ev)
 
   Config::SetBaseOrCurrent(Config::GFX_MSAA, vconfig.backend_info.AAModes[mode]);
 }
-
-void VideoConfigDiag::OnUberShaderModeChanged(wxCommandEvent& ev)
-{
-  // 0: No ubershaders
-  // 1: Hybrid ubershaders
-  // 2: Only ubershaders
-  int mode = ev.GetInt();
-  Config::SetBaseOrCurrent(Config::GFX_BACKGROUND_SHADER_COMPILING, mode == 1);
-  Config::SetBaseOrCurrent(Config::GFX_DISABLE_SPECIALIZED_SHADERS, mode == 2);
-}

Source/Core/DolphinWX/VideoConfigDiag.h

@@ -139,7 +139,6 @@ protected:
   void PopulatePostProcessingShaders();
   void PopulateAAList();
   void OnAAChanged(wxCommandEvent& ev);
-  void OnUberShaderModeChanged(wxCommandEvent& ev);
 
   wxChoice* choice_backend;
   wxChoice* choice_adapter;

Source/Core/VideoBackends/D3D/D3DState.cpp

@@ -212,6 +212,7 @@ StateCache::~StateCache()
 
 ID3D11SamplerState* StateCache::Get(SamplerState state)
 {
+  std::lock_guard<std::mutex> guard(m_lock);
   auto it = m_sampler.find(state.hex);
   if (it != m_sampler.end())
     return it->second;
@@ -266,6 +267,7 @@ ID3D11SamplerState* StateCache::Get(SamplerState state)
 
 ID3D11BlendState* StateCache::Get(BlendingState state)
 {
+  std::lock_guard<std::mutex> guard(m_lock);
   auto it = m_blend.find(state.hex);
   if (it != m_blend.end())
     return it->second;
@@ -348,6 +350,7 @@ ID3D11BlendState* StateCache::Get(BlendingState state)
 
 ID3D11RasterizerState* StateCache::Get(RasterizationState state)
 {
+  std::lock_guard<std::mutex> guard(m_lock);
   auto it = m_raster.find(state.hex);
   if (it != m_raster.end())
     return it->second;
@@ -372,6 +375,7 @@ ID3D11RasterizerState* StateCache::Get(RasterizationState state)
 
 ID3D11DepthStencilState* StateCache::Get(DepthState state)
 {
+  std::lock_guard<std::mutex> guard(m_lock);
   auto it = m_depth.find(state.hex);
   if (it != m_depth.end())
     return it->second;

Source/Core/VideoBackends/D3D/D3DState.h

@@ -6,6 +6,7 @@
 
 #include <array>
 #include <cstddef>
+#include <mutex>
 #include <unordered_map>
 
 #include "Common/BitField.h"
@@ -35,6 +36,7 @@ private:
   std::unordered_map<u32, ID3D11RasterizerState*> m_raster;
   std::unordered_map<u32, ID3D11BlendState*> m_blend;
   std::unordered_map<SamplerState::StorageType, ID3D11SamplerState*> m_sampler;
+  std::mutex m_lock;
 };
 
 namespace D3D

Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp

@@ -6,7 +6,6 @@
 
 #include "Common/Align.h"
 #include "Common/FileUtil.h"
-#include "Common/LinearDiskCache.h"
 #include "Common/StringUtil.h"
 
 #include "Core/ConfigManager.h"
@@ -25,16 +24,9 @@
 
 namespace DX11
 {
-GeometryShaderCache::GSCache GeometryShaderCache::GeometryShaders;
-const GeometryShaderCache::GSCacheEntry* GeometryShaderCache::last_entry;
-GeometryShaderUid GeometryShaderCache::last_uid;
-const GeometryShaderCache::GSCacheEntry GeometryShaderCache::pass_entry;
-
 ID3D11GeometryShader* ClearGeometryShader = nullptr;
 ID3D11GeometryShader* CopyGeometryShader = nullptr;
 
-LinearDiskCache<GeometryShaderUid, u8> g_gs_disk_cache;
-
 ID3D11GeometryShader* GeometryShaderCache::GetClearGeometryShader()
 {
   return (g_ActiveConfig.stereo_mode != StereoMode::Off) ? ClearGeometryShader : nullptr;
@@ -63,16 +55,6 @@ ID3D11Buffer*& GeometryShaderCache::GetConstantBuffer()
   return gscbuf;
 }
 
-// this class will load the precompiled shaders into our cache
-class GeometryShaderCacheInserter : public LinearDiskCacheReader<GeometryShaderUid, u8>
-{
-public:
-  void Read(const GeometryShaderUid& key, const u8* value, u32 value_size)
-  {
-    GeometryShaderCache::InsertByteCode(key, value, value_size);
-  }
-};
-
 const char clear_shader_code[] = {
     "struct VSOUTPUT\n"
     "{\n"
@@ -155,44 +137,6 @@ void GeometryShaderCache::Init()
   CopyGeometryShader = D3D::CompileAndCreateGeometryShader(copy_shader_code);
   CHECK(CopyGeometryShader != nullptr, "Create copy geometry shader");
   D3D::SetDebugObjectName(CopyGeometryShader, "copy geometry shader");
-
-  Clear();
-
-  if (g_ActiveConfig.bShaderCache)
-    LoadShaderCache();
-
-  if (g_ActiveConfig.CanPrecompileUberShaders())
-    PrecompileShaders();
-}
-
-void GeometryShaderCache::LoadShaderCache()
-{
-  GeometryShaderCacheInserter inserter;
-  g_gs_disk_cache.OpenAndRead(GetDiskShaderCacheFileName(APIType::D3D, "GS", true, true), inserter);
-}
-
-void GeometryShaderCache::Reload()
-{
-  g_gs_disk_cache.Sync();
-  g_gs_disk_cache.Close();
-  Clear();
-
-  if (g_ActiveConfig.bShaderCache)
-    LoadShaderCache();
-
-  if (g_ActiveConfig.CanPrecompileUberShaders())
-    PrecompileShaders();
-}
-
-// ONLY to be used during shutdown.
-void GeometryShaderCache::Clear()
-{
-  for (auto& iter : GeometryShaders)
-    iter.second.Destroy();
-  GeometryShaders.clear();
-
-  last_entry = nullptr;
-  last_uid = {};
 }
 
 void GeometryShaderCache::Shutdown()
@@ -201,83 +145,5 @@ void GeometryShaderCache::Shutdown()
 
   SAFE_RELEASE(ClearGeometryShader);
   SAFE_RELEASE(CopyGeometryShader);
-
-  Clear();
-  g_gs_disk_cache.Sync();
-  g_gs_disk_cache.Close();
 }
-
-bool GeometryShaderCache::SetShader(PrimitiveType primitive_type)
-{
-  GeometryShaderUid uid = GetGeometryShaderUid(primitive_type);
-  if (last_entry && uid == last_uid)
-  {
-    GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-    D3D::stateman->SetGeometryShader(last_entry->shader);
-    return true;
-  }
-
-  // Check if the shader is a pass-through shader
-  if (uid.GetUidData()->IsPassthrough())
-  {
-    // Return the default pass-through shader
-    last_uid = uid;
-    last_entry = &pass_entry;
-    D3D::stateman->SetGeometryShader(last_entry->shader);
-    return true;
-  }
-
-  // Check if the shader is already in the cache
-  auto iter = GeometryShaders.find(uid);
-  if (iter != GeometryShaders.end())
-  {
-    const GSCacheEntry& entry = iter->second;
-    last_uid = uid;
-    last_entry = &entry;
-    D3D::stateman->SetGeometryShader(last_entry->shader);
-    return (entry.shader != nullptr);
-  }
-
-  // Need to compile a new shader
-  if (CompileShader(uid))
-    return SetShader(primitive_type);
-  else
-    return false;
-}
-
-bool GeometryShaderCache::CompileShader(const GeometryShaderUid& uid)
-{
-  D3DBlob* bytecode;
-  ShaderCode code =
-      GenerateGeometryShaderCode(APIType::D3D, ShaderHostConfig::GetCurrent(), uid.GetUidData());
-  if (!D3D::CompileGeometryShader(code.GetBuffer(), &bytecode) ||
-      !InsertByteCode(uid, bytecode ? bytecode->Data() : nullptr, bytecode ? bytecode->Size() : 0))
-  {
-    SAFE_RELEASE(bytecode);
-    return false;
-  }
-
-  // Insert the bytecode into the caches
-  g_gs_disk_cache.Append(uid, bytecode->Data(), bytecode->Size());
-  return true;
-}
-
-bool GeometryShaderCache::InsertByteCode(const GeometryShaderUid& uid, const u8* bytecode,
-                                         size_t len)
-{
-  GSCacheEntry& newentry = GeometryShaders[uid];
-  newentry.shader = bytecode ? D3D::CreateGeometryShaderFromByteCode(bytecode, len) : nullptr;
-  return newentry.shader != nullptr;
-}
-
-void GeometryShaderCache::PrecompileShaders()
-{
-  EnumerateGeometryShaderUids([](const GeometryShaderUid& uid) {
-    if (GeometryShaders.find(uid) != GeometryShaders.end())
-      return;
-
-    CompileShader(uid);
-  });
-}
-
 }  // DX11

Source/Core/VideoBackends/D3D/GeometryShaderCache.h

@@ -15,36 +15,12 @@ class GeometryShaderCache
 {
 public:
   static void Init();
-  static void Reload();
-  static void Clear();
   static void Shutdown();
-  static bool SetShader(PrimitiveType primitive_type);
-  static bool CompileShader(const GeometryShaderUid& uid);
-  static bool InsertByteCode(const GeometryShaderUid& uid, const u8* bytecode, size_t len);
-  static void PrecompileShaders();
 
   static ID3D11GeometryShader* GetClearGeometryShader();
   static ID3D11GeometryShader* GetCopyGeometryShader();
 
   static ID3D11Buffer*& GetConstantBuffer();
-
-private:
-  struct GSCacheEntry
-  {
-    ID3D11GeometryShader* shader;
-
-    GSCacheEntry() : shader(nullptr) {}
-    void Destroy() { SAFE_RELEASE(shader); }
-  };
-
-  typedef std::map<GeometryShaderUid, GSCacheEntry> GSCache;
-
-  static void LoadShaderCache();
-
-  static GSCache GeometryShaders;
-  static const GSCacheEntry* last_entry;
-  static GeometryShaderUid last_uid;
-  static const GSCacheEntry pass_entry;
 };
 
 }  // namespace DX11

Source/Core/VideoBackends/D3D/NativeVertexFormat.cpp

@@ -13,6 +13,8 @@
 
 namespace DX11
 {
+std::mutex s_input_layout_lock;
+
 std::unique_ptr<NativeVertexFormat>
 VertexManager::CreateNativeVertexFormat(const PortableVertexDeclaration& vtx_decl)
 {
@@ -116,23 +118,34 @@ D3DVertexFormat::D3DVertexFormat(const PortableVertexDeclaration& _vtx_decl)
 
 D3DVertexFormat::~D3DVertexFormat()
 {
-  SAFE_RELEASE(m_layout);
+  ID3D11InputLayout* layout = m_layout.load();
+  SAFE_RELEASE(layout);
 }
 
 ID3D11InputLayout* D3DVertexFormat::GetInputLayout(D3DBlob* vs_bytecode)
 {
-  if (m_layout)
-    return m_layout;
+  // CreateInputLayout requires a shader input, but it only looks at the signature of the shader,
+  // so we don't need to recompute it if the shader changes.
+  ID3D11InputLayout* layout = m_layout.load();
+  if (layout)
+    return layout;
 
-  // CreateInputLayout requires a shader input, but it only looks at the
-  // signature of the shader, so we don't need to recompute it if the shader
-  // changes.
   HRESULT hr = DX11::D3D::device->CreateInputLayout(
-      m_elems.data(), m_num_elems, vs_bytecode->Data(), vs_bytecode->Size(), &m_layout);
+      m_elems.data(), m_num_elems, vs_bytecode->Data(), vs_bytecode->Size(), &layout);
   if (FAILED(hr))
     PanicAlert("Failed to create input layout, %s %d\n", __FILE__, __LINE__);
   DX11::D3D::SetDebugObjectName(m_layout, "input layout used to emulate the GX pipeline");
-  return m_layout;
+
+  // This method can be called from multiple threads, so ensure that only one thread sets the
+  // cached input layout pointer. If another thread beats this thread, use the existing layout.
+  ID3D11InputLayout* expected = nullptr;
+  if (!m_layout.compare_exchange_strong(expected, layout))
+  {
+    SAFE_RELEASE(layout);
+    layout = expected;
+  }
+
+  return layout;
 }
 
 }  // namespace DX11

Source/Core/VideoBackends/D3D/PixelShaderCache.cpp

@@ -7,7 +7,6 @@
 #include "Common/Align.h"
 #include "Common/CommonTypes.h"
 #include "Common/FileUtil.h"
-#include "Common/LinearDiskCache.h"
 #include "Common/MsgHandler.h"
 #include "Common/StringUtil.h"
 
@@ -27,17 +26,6 @@
 
 namespace DX11
 {
-PixelShaderCache::PSCache PixelShaderCache::PixelShaders;
-PixelShaderCache::UberPSCache PixelShaderCache::UberPixelShaders;
-const PixelShaderCache::PSCacheEntry* PixelShaderCache::last_entry;
-const PixelShaderCache::PSCacheEntry* PixelShaderCache::last_uber_entry;
-PixelShaderUid PixelShaderCache::last_uid;
-UberShader::PixelShaderUid PixelShaderCache::last_uber_uid;
-
-LinearDiskCache<PixelShaderUid, u8> g_ps_disk_cache;
-LinearDiskCache<UberShader::PixelShaderUid, u8> g_uber_ps_disk_cache;
-extern std::unique_ptr<VideoCommon::AsyncShaderCompiler> g_async_compiler;
-
 ID3D11PixelShader* s_ColorCopyProgram[2] = {nullptr};
 ID3D11PixelShader* s_ClearProgram = nullptr;
 ID3D11PixelShader* s_AnaglyphProgram = nullptr;
@@ -309,17 +297,6 @@ ID3D11Buffer* PixelShaderCache::GetConstantBuffer()
   return pscbuf;
 }
 
-// this class will load the precompiled shaders into our cache
-template <typename UidType>
-class PixelShaderCacheInserter : public LinearDiskCacheReader<UidType, u8>
-{
-public:
-  void Read(const UidType& key, const u8* value, u32 value_size)
-  {
-    PixelShaderCache::InsertByteCode(key, value, value_size);
-  }
-};
-
 void PixelShaderCache::Init()
 {
   unsigned int cbsize = Common::AlignUp(static_cast<unsigned int>(sizeof(PixelShaderConstants)),
@@ -344,58 +321,6 @@ void PixelShaderCache::Init()
   s_ColorCopyProgram[0] = D3D::CompileAndCreatePixelShader(color_copy_program_code);
   CHECK(s_ColorCopyProgram[0] != nullptr, "Create color copy pixel shader");
   D3D::SetDebugObjectName(s_ColorCopyProgram[0], "color copy pixel shader");
-
-  Clear();
-
-  SETSTAT(stats.numPixelShadersCreated, 0);
-  SETSTAT(stats.numPixelShadersAlive, 0);
-
-  if (g_ActiveConfig.bShaderCache)
-    LoadShaderCache();
-
-  if (g_ActiveConfig.CanPrecompileUberShaders())
-    QueueUberShaderCompiles();
-}
-
-void PixelShaderCache::LoadShaderCache()
-{
-  PixelShaderCacheInserter<PixelShaderUid> inserter;
-  g_ps_disk_cache.OpenAndRead(GetDiskShaderCacheFileName(APIType::D3D, "PS", true, true), inserter);
-
-  PixelShaderCacheInserter<UberShader::PixelShaderUid> uber_inserter;
-  g_uber_ps_disk_cache.OpenAndRead(GetDiskShaderCacheFileName(APIType::D3D, "UberPS", false, true),
-                                   uber_inserter);
-}
-
-void PixelShaderCache::Reload()
-{
-  g_ps_disk_cache.Sync();
-  g_ps_disk_cache.Close();
-  g_uber_ps_disk_cache.Sync();
-  g_uber_ps_disk_cache.Close();
-  Clear();
-
-  if (g_ActiveConfig.bShaderCache)
-    LoadShaderCache();
-
-  if (g_ActiveConfig.CanPrecompileUberShaders())
-    QueueUberShaderCompiles();
-}
-
-// ONLY to be used during shutdown.
-void PixelShaderCache::Clear()
-{
-  for (auto& iter : PixelShaders)
-    iter.second.Destroy();
-  for (auto& iter : UberPixelShaders)
-    iter.second.Destroy();
-  PixelShaders.clear();
-  UberPixelShaders.clear();
-
-  last_entry = nullptr;
-  last_uber_entry = nullptr;
-  last_uid = {};
-  last_uber_uid = {};
 }
 
 // Used in Swap() when AA mode has changed
@@ -420,255 +345,5 @@ void PixelShaderCache::Shutdown()
     SAFE_RELEASE(s_rgba6_to_rgb8[i]);
     SAFE_RELEASE(s_rgb8_to_rgba6[i]);
   }
-
-  Clear();
-  g_ps_disk_cache.Sync();
-  g_ps_disk_cache.Close();
-  g_uber_ps_disk_cache.Sync();
-  g_uber_ps_disk_cache.Close();
 }
-
-bool PixelShaderCache::SetShader()
-{
-  if (g_ActiveConfig.bDisableSpecializedShaders)
-    return SetUberShader();
-
-  PixelShaderUid uid = GetPixelShaderUid();
-  ClearUnusedPixelShaderUidBits(APIType::D3D, &uid);
-  if (last_entry && uid == last_uid)
-  {
-    if (last_entry->pending)
-      return SetUberShader();
-
-    if (!last_entry->shader)
-      return false;
-
-    D3D::stateman->SetPixelShader(last_entry->shader);
-    return true;
-  }
-
-  // Check if the shader is already in the cache
-  auto iter = PixelShaders.find(uid);
-  if (iter != PixelShaders.end())
-  {
-    const PSCacheEntry& entry = iter->second;
-    if (entry.pending)
-      return SetUberShader();
-
-    last_uid = uid;
-    last_entry = &entry;
-
-    GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-    if (!last_entry->shader)
-      return false;
-
-    D3D::stateman->SetPixelShader(last_entry->shader);
-    return true;
-  }
-
-  // Background compiling?
-  if (g_ActiveConfig.CanBackgroundCompileShaders())
-  {
-    // Create a pending entry
-    PSCacheEntry entry;
-    entry.pending = true;
-    PixelShaders[uid] = entry;
-
-    // Queue normal shader compiling and use ubershader
-    g_async_compiler->QueueWorkItem(
-        g_async_compiler->CreateWorkItem<PixelShaderCompilerWorkItem>(uid));
-    return SetUberShader();
-  }
-
-  // Need to compile a new shader
-  D3DBlob* bytecode = nullptr;
-  ShaderCode code =
-      GeneratePixelShaderCode(APIType::D3D, ShaderHostConfig::GetCurrent(), uid.GetUidData());
-  D3D::CompilePixelShader(code.GetBuffer(), &bytecode);
-  if (!InsertByteCode(uid, bytecode ? bytecode->Data() : nullptr, bytecode ? bytecode->Size() : 0))
-  {
-    SAFE_RELEASE(bytecode);
-    return false;
-  }
-
-  g_ps_disk_cache.Append(uid, bytecode->Data(), bytecode->Size());
-  return SetShader();
-}
-
-bool PixelShaderCache::SetUberShader()
-{
-  UberShader::PixelShaderUid uid = UberShader::GetPixelShaderUid();
-  UberShader::ClearUnusedPixelShaderUidBits(APIType::D3D, &uid);
-
-  if (last_uber_entry && last_uber_uid == uid)
-  {
-    if (!last_uber_entry->shader)
-      return false;
-
-    D3D::stateman->SetPixelShader(last_uber_entry->shader);
-    return true;
-  }
-
-  auto iter = UberPixelShaders.find(uid);
-  if (iter != UberPixelShaders.end())
-  {
-    const PSCacheEntry& entry = iter->second;
-    last_uber_uid = uid;
-    last_uber_entry = &entry;
-
-    GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
-    if (!last_uber_entry->shader)
-      return false;
-
-    D3D::stateman->SetPixelShader(last_uber_entry->shader);
-    return true;
-  }
-
-  D3DBlob* bytecode = nullptr;
-  ShaderCode code =
-      UberShader::GenPixelShader(APIType::D3D, ShaderHostConfig::GetCurrent(), uid.GetUidData());
-  D3D::CompilePixelShader(code.GetBuffer(), &bytecode);
-  if (!InsertByteCode(uid, bytecode ? bytecode->Data() : nullptr, bytecode ? bytecode->Size() : 0))
-  {
-    SAFE_RELEASE(bytecode);
-    return false;
-  }
-
-  // Lookup map again.
-  g_uber_ps_disk_cache.Append(uid, bytecode->Data(), bytecode->Size());
-  bytecode->Release();
-  return SetUberShader();
-}
-
-bool PixelShaderCache::InsertByteCode(const PixelShaderUid& uid, const u8* data, size_t len)
-{
-  ID3D11PixelShader* shader = data ? D3D::CreatePixelShaderFromByteCode(data, len) : nullptr;
-  if (!InsertShader(uid, shader))
-  {
-    SAFE_RELEASE(shader);
-    return false;
-  }
-
-  return true;
-}
-
-bool PixelShaderCache::InsertByteCode(const UberShader::PixelShaderUid& uid, const u8* data,
-                                      size_t len)
-{
-  ID3D11PixelShader* shader = data ? D3D::CreatePixelShaderFromByteCode(data, len) : nullptr;
-  if (!InsertShader(uid, shader))
-  {
-    SAFE_RELEASE(shader);
-    return false;
-  }
-
-  return true;
-}
-
-bool PixelShaderCache::InsertShader(const PixelShaderUid& uid, ID3D11PixelShader* shader)
-{
-  auto iter = PixelShaders.find(uid);
-  if (iter != PixelShaders.end() && !iter->second.pending)
-    return false;
-
-  PSCacheEntry& newentry = PixelShaders[uid];
-  newentry.pending = false;
-  newentry.shader = shader;
-
-  INCSTAT(stats.numPixelShadersCreated);
-  SETSTAT(stats.numPixelShadersAlive, PixelShaders.size());
-  return (shader != nullptr);
-}
-
-bool PixelShaderCache::InsertShader(const UberShader::PixelShaderUid& uid,
-                                    ID3D11PixelShader* shader)
-{
-  auto iter = UberPixelShaders.find(uid);
-  if (iter != UberPixelShaders.end() && !iter->second.pending)
-    return false;
-
-  PSCacheEntry& newentry = UberPixelShaders[uid];
-  newentry.pending = false;
-  newentry.shader = shader;
-  return (shader != nullptr);
-}
-
-void PixelShaderCache::QueueUberShaderCompiles()
-{
-  UberShader::EnumeratePixelShaderUids([&](const UberShader::PixelShaderUid& uid) {
-    if (UberPixelShaders.find(uid) != UberPixelShaders.end())
-      return;
-
-    g_async_compiler->QueueWorkItem(
-        g_async_compiler->CreateWorkItem<UberPixelShaderCompilerWorkItem>(uid));
-  });
-
-  g_async_compiler->WaitUntilCompletion([](size_t completed, size_t total) {
-    Host_UpdateProgressDialog(GetStringT("Compiling shaders...").c_str(),
-                              static_cast<int>(completed), static_cast<int>(total));
-  });
-  g_async_compiler->RetrieveWorkItems();
-  Host_UpdateProgressDialog("", -1, -1);
-}
-
-PixelShaderCache::PixelShaderCompilerWorkItem::PixelShaderCompilerWorkItem(
-    const PixelShaderUid& uid)
-{
-  std::memcpy(&m_uid, &uid, sizeof(uid));
-}
-
-PixelShaderCache::PixelShaderCompilerWorkItem::~PixelShaderCompilerWorkItem()
-{
-  SAFE_RELEASE(m_bytecode);
-}
-
-bool PixelShaderCache::PixelShaderCompilerWorkItem::Compile()
-{
-  ShaderCode code =
-      GeneratePixelShaderCode(APIType::D3D, ShaderHostConfig::GetCurrent(), m_uid.GetUidData());
-
-  if (D3D::CompilePixelShader(code.GetBuffer(), &m_bytecode))
-    m_shader = D3D::CreatePixelShaderFromByteCode(m_bytecode);
-
-  return true;
-}
-
-void PixelShaderCache::PixelShaderCompilerWorkItem::Retrieve()
-{
-  if (InsertShader(m_uid, m_shader))
-    g_ps_disk_cache.Append(m_uid, m_bytecode->Data(), m_bytecode->Size());
-  else
-    SAFE_RELEASE(m_shader);
-}
-
-PixelShaderCache::UberPixelShaderCompilerWorkItem::UberPixelShaderCompilerWorkItem(
-    const UberShader::PixelShaderUid& uid)
-{
-  std::memcpy(&m_uid, &uid, sizeof(uid));
-}
-
-PixelShaderCache::UberPixelShaderCompilerWorkItem::~UberPixelShaderCompilerWorkItem()
-{
-  SAFE_RELEASE(m_bytecode);
-}
-
-bool PixelShaderCache::UberPixelShaderCompilerWorkItem::Compile()
-{
-  ShaderCode code =
-      UberShader::GenPixelShader(APIType::D3D, ShaderHostConfig::GetCurrent(), m_uid.GetUidData());
-
-  if (D3D::CompilePixelShader(code.GetBuffer(), &m_bytecode))
-    m_shader = D3D::CreatePixelShaderFromByteCode(m_bytecode);
-
-  return true;
-}
-
-void PixelShaderCache::UberPixelShaderCompilerWorkItem::Retrieve()
-{
-  if (InsertShader(m_uid, m_shader))
-    g_uber_ps_disk_cache.Append(m_uid, m_bytecode->Data(), m_bytecode->Size());
-  else
-    SAFE_RELEASE(m_shader);
-}
-
 }  // DX11

Source/Core/VideoBackends/D3D/PixelShaderCache.h

@@ -19,16 +19,7 @@ class PixelShaderCache
 {
 public:
   static void Init();
-  static void Reload();
-  static void Clear();
   static void Shutdown();
-  static bool SetShader();
-  static bool SetUberShader();
-  static bool InsertByteCode(const PixelShaderUid& uid, const u8* data, size_t len);
-  static bool InsertByteCode(const UberShader::PixelShaderUid& uid, const u8* data, size_t len);
-  static bool InsertShader(const PixelShaderUid& uid, ID3D11PixelShader* shader);
-  static bool InsertShader(const UberShader::PixelShaderUid& uid, ID3D11PixelShader* shader);
-  static void QueueUberShaderCompiles();
 
   static ID3D11Buffer* GetConstantBuffer();
 
@@ -40,58 +31,6 @@ public:
   static ID3D11PixelShader* ReinterpRGB8ToRGBA6(bool multisampled);
 
   static void InvalidateMSAAShaders();
-
-private:
-  struct PSCacheEntry
-  {
-    ID3D11PixelShader* shader;
-    bool pending;
-
-    PSCacheEntry() : shader(nullptr), pending(false) {}
-    void Destroy() { SAFE_RELEASE(shader); }
-  };
-
-  class PixelShaderCompilerWorkItem : public VideoCommon::AsyncShaderCompiler::WorkItem
-  {
-  public:
-    explicit PixelShaderCompilerWorkItem(const PixelShaderUid& uid);
-    ~PixelShaderCompilerWorkItem() override;
-
-    bool Compile() override;
-    void Retrieve() override;
-
-  private:
-    PixelShaderUid m_uid;
-    ID3D11PixelShader* m_shader = nullptr;
-    D3DBlob* m_bytecode = nullptr;
-  };
-
-  class UberPixelShaderCompilerWorkItem : public VideoCommon::AsyncShaderCompiler::WorkItem
-  {
-  public:
-    explicit UberPixelShaderCompilerWorkItem(const UberShader::PixelShaderUid& uid);
-    ~UberPixelShaderCompilerWorkItem() override;
-
-    bool Compile() override;
-    void Retrieve() override;
-
-  private:
-    UberShader::PixelShaderUid m_uid;
-    ID3D11PixelShader* m_shader = nullptr;
-    D3DBlob* m_bytecode = nullptr;
-  };
-
-  typedef std::map<PixelShaderUid, PSCacheEntry> PSCache;
-  typedef std::map<UberShader::PixelShaderUid, PSCacheEntry> UberPSCache;
-
-  static void LoadShaderCache();
-
-  static PSCache PixelShaders;
-  static UberPSCache UberPixelShaders;
-  static const PSCacheEntry* last_entry;
-  static const PSCacheEntry* last_uber_entry;
-  static PixelShaderUid last_uid;
-  static UberShader::PixelShaderUid last_uber_uid;
 };
 
 }  // namespace DX11

Source/Core/VideoBackends/D3D/Render.cpp

@@ -71,15 +71,6 @@ Renderer::Renderer(int backbuffer_width, int backbuffer_height)
   g_framebuffer_manager = std::make_unique<FramebufferManager>(m_target_width, m_target_height);
   SetupDeviceObjects();
 
-  // Setup GX pipeline state
-  for (auto& sampler : m_gx_state.samplers)
-    sampler.hex = RenderState::GetPointSamplerState().hex;
-
-  m_gx_state.zmode.testenable = false;
-  m_gx_state.zmode.updateenable = false;
-  m_gx_state.zmode.func = ZMode::NEVER;
-  m_gx_state.raster.cullmode = GenMode::CULL_NONE;
-
   // Clear EFB textures
   constexpr std::array<float, 4> clear_color{{0.f, 0.f, 0.f, 1.f}};
   D3D::context->ClearRenderTargetView(FramebufferManager::GetEFBColorTexture()->GetRTV(),
@@ -299,6 +290,8 @@ void Renderer::UpdateUtilityVertexBuffer(const void* vertices, u32 vertex_stride
 void Renderer::SetPipeline(const AbstractPipeline* pipeline)
 {
   const DXPipeline* dx_pipeline = static_cast<const DXPipeline*>(pipeline);
+  if (!dx_pipeline)
+    return;
 
   D3D::stateman->SetRasterizerState(dx_pipeline->GetRasterizerState());
   D3D::stateman->SetDepthState(dx_pipeline->GetDepthState());
@@ -313,11 +306,6 @@ void Renderer::SetPipeline(const AbstractPipeline* pipeline)
 void Renderer::DrawUtilityPipeline(const void* uniforms, u32 uniforms_size, const void* vertices,
                                    u32 vertex_stride, u32 num_vertices)
 {
-  // Textures are fine, they're set directly via SetTexture.
-  // Since samplers are set via gx_state, we need to fix this up here.
-  for (size_t stage = 0; stage < m_gx_state.samplers.size(); stage++)
-    D3D::stateman->SetSampler(stage, m_state_cache.Get(m_gx_state.samplers[stage]));
-
   // Copy in uniforms.
   if (uniforms_size > 0)
   {
@@ -638,11 +626,6 @@ void Renderer::ReinterpretPixelData(unsigned int convtype)
   RestoreAPIState();
 }
 
-void Renderer::SetBlendingState(const BlendingState& state)
-{
-  m_gx_state.blend.hex = state.hex;
-}
-
 // This function has the final picture. We adjust the aspect ratio here.
 void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region, u64 ticks,
                         float Gamma)
@@ -683,7 +666,6 @@ void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region
   // Enable configuration changes
   UpdateActiveConfig();
   g_texture_cache->OnConfigChanged(g_ActiveConfig);
-  VertexShaderCache::RetreiveAsyncShaders();
 
   // Flip/present backbuffer to frontbuffer here
   if (D3D::swapchain)
@@ -706,12 +688,7 @@ void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region
                                         D3D11_CLEAR_DEPTH, 0.f, 0);
   }
 
-  if (CheckForHostConfigChanges())
-  {
-    VertexShaderCache::Reload();
-    GeometryShaderCache::Reload();
-    PixelShaderCache::Reload();
-  }
+  CheckForHostConfigChanges();
 
   // begin next frame
   RestoreAPIState();
@@ -784,30 +761,6 @@ void Renderer::RestoreAPIState()
   BPFunctions::SetScissor();
 }
 
-void Renderer::ApplyState()
-{
-  D3D::stateman->SetBlendState(m_state_cache.Get(m_gx_state.blend));
-  D3D::stateman->SetDepthState(m_state_cache.Get(m_gx_state.zmode));
-  D3D::stateman->SetRasterizerState(m_state_cache.Get(m_gx_state.raster));
-  D3D::stateman->SetPrimitiveTopology(
-      StateCache::GetPrimitiveTopology(m_gx_state.raster.primitive));
-  FramebufferManager::SetIntegerEFBRenderTarget(m_gx_state.blend.logicopenable);
-
-  for (u32 stage = 0; stage < static_cast<u32>(m_gx_state.samplers.size()); stage++)
-    D3D::stateman->SetSampler(stage, m_state_cache.Get(m_gx_state.samplers[stage]));
-
-  ID3D11Buffer* vertexConstants = VertexShaderCache::GetConstantBuffer();
-
-  D3D::stateman->SetPixelConstants(PixelShaderCache::GetConstantBuffer(),
-                                   g_ActiveConfig.bEnablePixelLighting ? vertexConstants : nullptr);
-  D3D::stateman->SetVertexConstants(vertexConstants);
-  D3D::stateman->SetGeometryConstants(GeometryShaderCache::GetConstantBuffer());
-}
-
-void Renderer::RestoreState()
-{
-}
-
 void Renderer::SetFramebuffer(const AbstractFramebuffer* framebuffer)
 {
   const DXFramebuffer* fb = static_cast<const DXFramebuffer*>(framebuffer);
@@ -838,16 +791,6 @@ void Renderer::SetAndClearFramebuffer(const AbstractFramebuffer* framebuffer,
   }
 }
 
-void Renderer::SetRasterizationState(const RasterizationState& state)
-{
-  m_gx_state.raster.hex = state.hex;
-}
-
-void Renderer::SetDepthState(const DepthState& state)
-{
-  m_gx_state.zmode.hex = state.hex;
-}
-
 void Renderer::SetTexture(u32 index, const AbstractTexture* texture)
 {
   D3D::stateman->SetTexture(
@@ -857,7 +800,7 @@ void Renderer::SetTexture(u32 index, const AbstractTexture* texture)
 
 void Renderer::SetSamplerState(u32 index, const SamplerState& state)
 {
-  m_gx_state.samplers[index].hex = state.hex;
+  D3D::stateman->SetSampler(index, m_state_cache.Get(state));
 }
 
 void Renderer::UnbindTexture(const AbstractTexture* texture)

Source/Core/VideoBackends/D3D/Render.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <array>
 #include <d3d11.h>
 #include <string>
 #include "VideoBackends/D3D/D3DState.h"
@@ -41,10 +40,7 @@ public:
   void SetAndClearFramebuffer(const AbstractFramebuffer* framebuffer,
                               const ClearColor& color_value = {},
                               float depth_value = 0.0f) override;
-  void SetBlendingState(const BlendingState& state) override;
   void SetScissorRect(const MathUtil::Rectangle<int>& rc) override;
-  void SetRasterizationState(const RasterizationState& state) override;
-  void SetDepthState(const DepthState& state) override;
   void SetTexture(u32 index, const AbstractTexture* texture) override;
   void SetSamplerState(u32 index, const SamplerState& state) override;
   void UnbindTexture(const AbstractTexture* texture) override;
@@ -54,10 +50,6 @@ public:
   void SetFullscreen(bool enable_fullscreen) override;
   bool IsFullscreen() const override;
 
-  // TODO: Fix confusing names (see ResetAPIState and RestoreAPIState)
-  void ApplyState() override;
-  void RestoreState() override;
-
   void RenderText(const std::string& text, int left, int top, u32 color) override;
 
   u32 AccessEFB(EFBAccessType type, u32 x, u32 y, u32 poke_data) override;
@@ -84,14 +76,6 @@ public:
                              u32 groups_x, u32 groups_y, u32 groups_z) override;
 
 private:
-  struct GXPipelineState
-  {
-    std::array<SamplerState, 8> samplers;
-    BlendingState blend;
-    DepthState zmode;
-    RasterizationState raster;
-  };
-
   void SetupDeviceObjects();
   void TeardownDeviceObjects();
   void Create3DVisionTexture(int width, int height);
@@ -106,7 +90,6 @@ private:
   void UpdateUtilityVertexBuffer(const void* vertices, u32 vertex_stride, u32 num_vertices);
 
   StateCache m_state_cache;
-  GXPipelineState m_gx_state;
 
   std::array<ID3D11BlendState*, 4> m_clear_blend_states{};
   std::array<ID3D11DepthStencilState*, 3> m_clear_depth_states{};