Merge pull request #3513 from phire/make_hdkr_happy

Get shadergen ready for Multithreadded generation of shaders.

11 files changed, 34 insertions, 182 deletions

diff --git a/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp b/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp
index f899f7f078..1452e617e3 100644
--- a/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/GeometryShaderCache.cpp
@@ -26,7 +26,6 @@ namespace DX11
 GeometryShaderCache::GSCache GeometryShaderCache::GeometryShaders;
 const GeometryShaderCache::GSCacheEntry* GeometryShaderCache::last_entry;
 GeometryShaderUid GeometryShaderCache::last_uid;
-UidChecker<GeometryShaderUid, ShaderCode> GeometryShaderCache::geometry_uid_checker;
 const GeometryShaderCache::GSCacheEntry GeometryShaderCache::pass_entry;
 
 ID3D11GeometryShader* ClearGeometryShader = nullptr;
@@ -165,9 +164,6 @@ void GeometryShaderCache::Init()
   GeometryShaderCacheInserter inserter;
   g_gs_disk_cache.OpenAndRead(cache_filename, inserter);
 
-  if (g_Config.bEnableShaderDebugging)
-    Clear();
-
   last_entry = nullptr;
 }
 
@@ -177,7 +173,6 @@ void GeometryShaderCache::Clear()
   for (auto& iter : GeometryShaders)
     iter.second.Destroy();
   GeometryShaders.clear();
-  geometry_uid_checker.Invalidate();
 
   last_entry = nullptr;
 }
@@ -196,12 +191,7 @@ void GeometryShaderCache::Shutdown()
 
 bool GeometryShaderCache::SetShader(u32 primitive_type)
 {
-  GeometryShaderUid uid = GetGeometryShaderUid(primitive_type, API_D3D);
-  if (g_ActiveConfig.bEnableShaderDebugging)
-  {
-    ShaderCode code = GenerateGeometryShaderCode(primitive_type, API_D3D);
-    geometry_uid_checker.AddToIndexAndCheck(code, uid, "Geometry", "g");
-  }
+  GeometryShaderUid uid = GetGeometryShaderUid(primitive_type);
 
   // Check if the shader is already set
   if (last_entry)
@@ -235,7 +225,7 @@ bool GeometryShaderCache::SetShader(u32 primitive_type)
   }
 
   // Need to compile a new shader
-  ShaderCode code = GenerateGeometryShaderCode(primitive_type, API_D3D);
+  ShaderCode code = GenerateGeometryShaderCode(API_D3D, uid.GetUidData());
 
   D3DBlob* pbytecode;
   if (!D3D::CompileGeometryShader(code.GetBuffer(), &pbytecode))
@@ -250,11 +240,6 @@ bool GeometryShaderCache::SetShader(u32 primitive_type)
   bool success = InsertByteCode(uid, pbytecode->Data(), pbytecode->Size());
   pbytecode->Release();
 
-  if (g_ActiveConfig.bEnableShaderDebugging && success)
-  {
-    GeometryShaders[uid].code = code.GetBuffer();
-  }
-
   return success;
 }
 
diff --git a/Source/Core/VideoBackends/D3D/GeometryShaderCache.h b/Source/Core/VideoBackends/D3D/GeometryShaderCache.h
index b3c17cd37f..f0cab99940 100644
--- a/Source/Core/VideoBackends/D3D/GeometryShaderCache.h
+++ b/Source/Core/VideoBackends/D3D/GeometryShaderCache.h
@@ -32,8 +32,6 @@ private:
   {
     ID3D11GeometryShader* shader;
 
-    std::string code;
-
     GSCacheEntry() : shader(nullptr) {}
     void Destroy() { SAFE_RELEASE(shader); }
   };
@@ -44,8 +42,6 @@ private:
   static const GSCacheEntry* last_entry;
   static GeometryShaderUid last_uid;
   static const GSCacheEntry pass_entry;
-
-  static UidChecker<GeometryShaderUid, ShaderCode> geometry_uid_checker;
 };
 
 }  // namespace DX11
diff --git a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
index 3d48784647..7e6bc036e7 100644
--- a/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/PixelShaderCache.cpp
@@ -26,7 +26,6 @@ namespace DX11
 PixelShaderCache::PSCache PixelShaderCache::PixelShaders;
 const PixelShaderCache::PSCacheEntry* PixelShaderCache::last_entry;
 PixelShaderUid PixelShaderCache::last_uid;
-UidChecker<PixelShaderUid, ShaderCode> PixelShaderCache::pixel_uid_checker;
 
 LinearDiskCache<PixelShaderUid, u8> g_ps_disk_cache;
 
@@ -505,9 +504,6 @@ void PixelShaderCache::Init()
   PixelShaderCacheInserter inserter;
   g_ps_disk_cache.OpenAndRead(cache_filename, inserter);
 
-  if (g_Config.bEnableShaderDebugging)
-    Clear();
-
   last_entry = nullptr;
 }
 
@@ -517,7 +513,6 @@ void PixelShaderCache::Clear()
   for (auto& iter : PixelShaders)
     iter.second.Destroy();
   PixelShaders.clear();
-  pixel_uid_checker.Invalidate();
 
   last_entry = nullptr;
 }
@@ -556,12 +551,7 @@ void PixelShaderCache::Shutdown()
 
 bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode)
 {
-  PixelShaderUid uid = GetPixelShaderUid(dstAlphaMode, API_D3D);
-  if (g_ActiveConfig.bEnableShaderDebugging)
-  {
-    ShaderCode code = GeneratePixelShaderCode(dstAlphaMode, API_D3D);
-    pixel_uid_checker.AddToIndexAndCheck(code, uid, "Pixel", "p");
-  }
+  PixelShaderUid uid = GetPixelShaderUid(dstAlphaMode);
 
   // Check if the shader is already set
   if (last_entry)
@@ -588,7 +578,7 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode)
   }
 
   // Need to compile a new shader
-  ShaderCode code = GeneratePixelShaderCode(dstAlphaMode, API_D3D);
+  ShaderCode code = GeneratePixelShaderCode(dstAlphaMode, API_D3D, uid.GetUidData());
 
   D3DBlob* pbytecode;
   if (!D3D::CompilePixelShader(code.GetBuffer(), &pbytecode))
@@ -603,11 +593,6 @@ bool PixelShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode)
   bool success = InsertByteCode(uid, pbytecode->Data(), pbytecode->Size());
   pbytecode->Release();
 
-  if (g_ActiveConfig.bEnableShaderDebugging && success)
-  {
-    PixelShaders[uid].code = code.GetBuffer();
-  }
-
   GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
   return success;
 }
diff --git a/Source/Core/VideoBackends/D3D/PixelShaderCache.h b/Source/Core/VideoBackends/D3D/PixelShaderCache.h
index e985374f97..0e81f3cf33 100644
--- a/Source/Core/VideoBackends/D3D/PixelShaderCache.h
+++ b/Source/Core/VideoBackends/D3D/PixelShaderCache.h
@@ -42,8 +42,6 @@ private:
   {
     ID3D11PixelShader* shader;
 
-    std::string code;
-
     PSCacheEntry() : shader(nullptr) {}
     void Destroy() { SAFE_RELEASE(shader); }
   };
@@ -53,8 +51,6 @@ private:
   static PSCache PixelShaders;
   static const PSCacheEntry* last_entry;
   static PixelShaderUid last_uid;
-
-  static UidChecker<PixelShaderUid, ShaderCode> pixel_uid_checker;
 };
 
 }  // namespace DX11
diff --git a/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp b/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
index 7b3f71da26..cdcff17d02 100644
--- a/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D/VertexShaderCache.cpp
@@ -24,7 +24,6 @@ namespace DX11
 VertexShaderCache::VSCache VertexShaderCache::vshaders;
 const VertexShaderCache::VSCacheEntry* VertexShaderCache::last_entry;
 VertexShaderUid VertexShaderCache::last_uid;
-UidChecker<VertexShaderUid, ShaderCode> VertexShaderCache::vertex_uid_checker;
 
 static ID3D11VertexShader* SimpleVertexShader = nullptr;
 static ID3D11VertexShader* ClearVertexShader = nullptr;
@@ -166,9 +165,6 @@ void VertexShaderCache::Init()
   VertexShaderCacheInserter inserter;
   g_vs_disk_cache.OpenAndRead(cache_filename, inserter);
 
-  if (g_Config.bEnableShaderDebugging)
-    Clear();
-
   last_entry = nullptr;
 }
 
@@ -177,7 +173,6 @@ void VertexShaderCache::Clear()
   for (auto& iter : vshaders)
     iter.second.Destroy();
   vshaders.clear();
-  vertex_uid_checker.Invalidate();
 
   last_entry = nullptr;
 }
@@ -199,12 +194,7 @@ void VertexShaderCache::Shutdown()
 
 bool VertexShaderCache::SetShader()
 {
-  VertexShaderUid uid = GetVertexShaderUid(API_D3D);
-  if (g_ActiveConfig.bEnableShaderDebugging)
-  {
-    ShaderCode code = GenerateVertexShaderCode(API_D3D);
-    vertex_uid_checker.AddToIndexAndCheck(code, uid, "Vertex", "v");
-  }
+  VertexShaderUid uid = GetVertexShaderUid();
 
   if (last_entry)
   {
@@ -227,7 +217,7 @@ bool VertexShaderCache::SetShader()
     return (entry.shader != nullptr);
   }
 
-  ShaderCode code = GenerateVertexShaderCode(API_D3D);
+  ShaderCode code = GenerateVertexShaderCode(API_D3D, uid.GetUidData());
 
   D3DBlob* pbytecode = nullptr;
   D3D::CompileVertexShader(code.GetBuffer(), &pbytecode);
@@ -242,11 +232,6 @@ bool VertexShaderCache::SetShader()
   bool success = InsertByteCode(uid, pbytecode);
   pbytecode->Release();
 
-  if (g_ActiveConfig.bEnableShaderDebugging && success)
-  {
-    vshaders[uid].code = code.GetBuffer();
-  }
-
   GFX_DEBUGGER_PAUSE_AT(NEXT_VERTEX_SHADER_CHANGE, true);
   return success;
 }
diff --git a/Source/Core/VideoBackends/D3D/VertexShaderCache.h b/Source/Core/VideoBackends/D3D/VertexShaderCache.h
index d680fca6de..7471d4f769 100644
--- a/Source/Core/VideoBackends/D3D/VertexShaderCache.h
+++ b/Source/Core/VideoBackends/D3D/VertexShaderCache.h
@@ -38,8 +38,6 @@ private:
     ID3D11VertexShader* shader;
     D3DBlob* bytecode;  // needed to initialize the input layout
 
-    std::string code;
-
     VSCacheEntry() : shader(nullptr), bytecode(nullptr) {}
     void SetByteCode(D3DBlob* blob)
     {
@@ -58,8 +56,6 @@ private:
   static VSCache vshaders;
   static const VSCacheEntry* last_entry;
   static VertexShaderUid last_uid;
-
-  static UidChecker<VertexShaderUid, ShaderCode> vertex_uid_checker;
 };
 
 }  // namespace DX11
diff --git a/Source/Core/VideoBackends/D3D12/ShaderCache.cpp b/Source/Core/VideoBackends/D3D12/ShaderCache.cpp
index 2f93956003..e1803111d3 100644
--- a/Source/Core/VideoBackends/D3D12/ShaderCache.cpp
+++ b/Source/Core/VideoBackends/D3D12/ShaderCache.cpp
@@ -30,22 +30,10 @@ VsBytecodeCache s_vs_bytecode_cache;
 // Used to keep track of blobs to release at Shutdown time.
 static std::vector<ID3DBlob*> s_shader_blob_list;
 
-// Only used for shader debugging..
-using GsHlslCache = std::map<GeometryShaderUid, std::string>;
-using PsHlslCache = std::map<PixelShaderUid, std::string>;
-using VsHlslCache = std::map<VertexShaderUid, std::string>;
-static GsHlslCache s_gs_hlsl_cache;
-static PsHlslCache s_ps_hlsl_cache;
-static VsHlslCache s_vs_hlsl_cache;
-
 static LinearDiskCache<GeometryShaderUid, u8> s_gs_disk_cache;
 static LinearDiskCache<PixelShaderUid, u8> s_ps_disk_cache;
 static LinearDiskCache<VertexShaderUid, u8> s_vs_disk_cache;
 
-static UidChecker<GeometryShaderUid, ShaderCode> s_geometry_uid_checker;
-static UidChecker<PixelShaderUid, ShaderCode> s_pixel_uid_checker;
-static UidChecker<VertexShaderUid, ShaderCode> s_vertex_uid_checker;
-
 static D3D12_SHADER_BYTECODE s_last_geometry_shader_bytecode;
 static D3D12_SHADER_BYTECODE s_last_pixel_shader_bytecode;
 static D3D12_SHADER_BYTECODE s_last_vertex_shader_bytecode;
@@ -104,10 +92,6 @@ void ShaderCache::Init()
   ShaderCacheInserter<VertexShaderUid, VsBytecodeCache, &s_vs_bytecode_cache> vs_inserter;
   s_vs_disk_cache.OpenAndRead(vs_cache_filename, vs_inserter);
 
-  // Clear out cache when debugging shaders to ensure stale ones don't stick around..
-  if (g_Config.bEnableShaderDebugging)
-    Clear();
-
   SETSTAT(stats.numPixelShadersAlive, static_cast<int>(s_ps_bytecode_cache.size()));
   SETSTAT(stats.numPixelShadersCreated, static_cast<int>(s_ps_bytecode_cache.size()));
   SETSTAT(stats.numVertexShadersAlive, static_cast<int>(s_vs_bytecode_cache.size()));
@@ -145,26 +129,15 @@ void ShaderCache::Shutdown()
   s_ps_disk_cache.Close();
   s_vs_disk_cache.Sync();
   s_vs_disk_cache.Close();
-
-  if (g_Config.bEnableShaderDebugging)
-  {
-    s_gs_hlsl_cache.clear();
-    s_ps_hlsl_cache.clear();
-    s_vs_hlsl_cache.clear();
-  }
-
-  s_geometry_uid_checker.Invalidate();
-  s_pixel_uid_checker.Invalidate();
-  s_vertex_uid_checker.Invalidate();
 }
 
 void ShaderCache::LoadAndSetActiveShaders(DSTALPHA_MODE ps_dst_alpha_mode, u32 gs_primitive_type)
 {
   SetCurrentPrimitiveTopology(gs_primitive_type);
 
-  GeometryShaderUid gs_uid = GetGeometryShaderUid(gs_primitive_type, API_D3D);
-  PixelShaderUid ps_uid = GetPixelShaderUid(ps_dst_alpha_mode, API_D3D);
-  VertexShaderUid vs_uid = GetVertexShaderUid(API_D3D);
+  GeometryShaderUid gs_uid = GetGeometryShaderUid(gs_primitive_type);
+  PixelShaderUid ps_uid = GetPixelShaderUid(ps_dst_alpha_mode);
+  VertexShaderUid vs_uid = GetVertexShaderUid();
 
   bool gs_changed = gs_uid != s_last_geometry_shader_uid;
   bool ps_changed = ps_uid != s_last_pixel_shader_uid;
@@ -217,12 +190,6 @@ void ShaderCache::HandleGSUIDChange(GeometryShaderUid gs_uid, u32 gs_primitive_t
 {
   s_last_geometry_shader_uid = gs_uid;
 
-  if (g_ActiveConfig.bEnableShaderDebugging)
-  {
-    ShaderCode code = GenerateGeometryShaderCode(gs_primitive_type, API_D3D);
-    s_geometry_uid_checker.AddToIndexAndCheck(code, gs_uid, "Geometry", "g");
-  }
-
   if (gs_uid.GetUidData()->IsPassthrough())
   {
     s_last_geometry_shader_bytecode = {};
@@ -236,7 +203,7 @@ void ShaderCache::HandleGSUIDChange(GeometryShaderUid gs_uid, u32 gs_primitive_t
   }
   else
   {
-    ShaderCode gs_code = GenerateGeometryShaderCode(gs_primitive_type, API_D3D);
+    ShaderCode gs_code = GenerateGeometryShaderCode(API_D3D, gs_uid.GetUidData());
     ID3DBlob* gs_bytecode = nullptr;
 
     if (!D3D::CompileGeometryShader(gs_code.GetBuffer(), &gs_bytecode))
@@ -248,11 +215,6 @@ void ShaderCache::HandleGSUIDChange(GeometryShaderUid gs_uid, u32 gs_primitive_t
     s_last_geometry_shader_bytecode = InsertByteCode(gs_uid, &s_gs_bytecode_cache, gs_bytecode);
     s_gs_disk_cache.Append(gs_uid, reinterpret_cast<u8*>(gs_bytecode->GetBufferPointer()),
                            static_cast<u32>(gs_bytecode->GetBufferSize()));
-
-    if (g_ActiveConfig.bEnableShaderDebugging)
-    {
-      s_gs_hlsl_cache[gs_uid] = gs_code.GetBuffer();
-    }
   }
 }
 
@@ -260,12 +222,6 @@ void ShaderCache::HandlePSUIDChange(PixelShaderUid ps_uid, DSTALPHA_MODE ps_dst_
 {
   s_last_pixel_shader_uid = ps_uid;
 
-  if (g_ActiveConfig.bEnableShaderDebugging)
-  {
-    ShaderCode code = GeneratePixelShaderCode(ps_dst_alpha_mode, API_D3D);
-    s_pixel_uid_checker.AddToIndexAndCheck(code, ps_uid, "Pixel", "p");
-  }
-
   auto ps_iterator = s_ps_bytecode_cache.find(ps_uid);
   if (ps_iterator != s_ps_bytecode_cache.end())
   {
@@ -274,7 +230,7 @@ void ShaderCache::HandlePSUIDChange(PixelShaderUid ps_uid, DSTALPHA_MODE ps_dst_
   }
   else
   {
-    ShaderCode ps_code = GeneratePixelShaderCode(ps_dst_alpha_mode, API_D3D);
+    ShaderCode ps_code = GeneratePixelShaderCode(ps_dst_alpha_mode, API_D3D, ps_uid.GetUidData());
     ID3DBlob* ps_bytecode = nullptr;
 
     if (!D3D::CompilePixelShader(ps_code.GetBuffer(), &ps_bytecode))
@@ -289,11 +245,6 @@ void ShaderCache::HandlePSUIDChange(PixelShaderUid ps_uid, DSTALPHA_MODE ps_dst_
 
     SETSTAT(stats.numPixelShadersAlive, static_cast<int>(s_ps_bytecode_cache.size()));
     INCSTAT(stats.numPixelShadersCreated);
-
-    if (g_ActiveConfig.bEnableShaderDebugging)
-    {
-      s_ps_hlsl_cache[ps_uid] = ps_code.GetBuffer();
-    }
   }
 }
 
@@ -301,12 +252,6 @@ void ShaderCache::HandleVSUIDChange(VertexShaderUid vs_uid)
 {
   s_last_vertex_shader_uid = vs_uid;
 
-  if (g_ActiveConfig.bEnableShaderDebugging)
-  {
-    ShaderCode code = GenerateVertexShaderCode(API_D3D);
-    s_vertex_uid_checker.AddToIndexAndCheck(code, vs_uid, "Vertex", "v");
-  }
-
   auto vs_iterator = s_vs_bytecode_cache.find(vs_uid);
   if (vs_iterator != s_vs_bytecode_cache.end())
   {
@@ -315,7 +260,7 @@ void ShaderCache::HandleVSUIDChange(VertexShaderUid vs_uid)
   }
   else
   {
-    ShaderCode vs_code = GenerateVertexShaderCode(API_D3D);
+    ShaderCode vs_code = GenerateVertexShaderCode(API_D3D, vs_uid.GetUidData());
     ID3DBlob* vs_bytecode = nullptr;
 
     if (!D3D::CompileVertexShader(vs_code.GetBuffer(), &vs_bytecode))
@@ -330,11 +275,6 @@ void ShaderCache::HandleVSUIDChange(VertexShaderUid vs_uid)
 
     SETSTAT(stats.numVertexShadersAlive, static_cast<int>(s_vs_bytecode_cache.size()));
     INCSTAT(stats.numVertexShadersCreated);
-
-    if (g_ActiveConfig.bEnableShaderDebugging)
-    {
-      s_vs_hlsl_cache[vs_uid] = vs_code.GetBuffer();
-    }
   }
 }
 
diff --git a/Source/Core/VideoBackends/Null/ShaderCache.cpp b/Source/Core/VideoBackends/Null/ShaderCache.cpp
index e0fa000765..a08ef6952b 100644
--- a/Source/Core/VideoBackends/Null/ShaderCache.cpp
+++ b/Source/Core/VideoBackends/Null/ShaderCache.cpp
@@ -59,7 +59,7 @@ bool ShaderCache<Uid>::SetShader(DSTALPHA_MODE dst_alpha_mode, u32 primitive_typ
   }
 
   // Need to compile a new shader
-  ShaderCode code = GenerateCode(dst_alpha_mode, primitive_type, API_OPENGL);
+  ShaderCode code = GenerateCode(dst_alpha_mode, API_OPENGL, uid);
   m_shaders.emplace(uid, code.GetBuffer());
 
   GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
diff --git a/Source/Core/VideoBackends/Null/ShaderCache.h b/Source/Core/VideoBackends/Null/ShaderCache.h
index 833c8acf36..2dcdaf85b7 100644
--- a/Source/Core/VideoBackends/Null/ShaderCache.h
+++ b/Source/Core/VideoBackends/Null/ShaderCache.h
@@ -26,14 +26,12 @@ public:
 
 protected:
   virtual Uid GetUid(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type, API_TYPE api_type) = 0;
-  virtual ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type,
-                                  API_TYPE api_type) = 0;
+  virtual ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, API_TYPE api_type, Uid uid) = 0;
 
 private:
   std::map<Uid, std::string> m_shaders;
   const std::string* m_last_entry = nullptr;
   Uid m_last_uid;
-  UidChecker<Uid, ShaderCode> m_uid_checker;
 };
 
 class VertexShaderCache : public ShaderCache<VertexShaderUid>
@@ -45,12 +43,12 @@ protected:
   VertexShaderUid GetUid(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type,
                          API_TYPE api_type) override
   {
-    return GetVertexShaderUid(api_type);
+    return GetVertexShaderUid();
   }
-  ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type,
-                          API_TYPE api_type) override
+  ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, API_TYPE api_type,
+                          VertexShaderUid uid) override
   {
-    return GenerateVertexShaderCode(api_type);
+    return GenerateVertexShaderCode(api_type, uid.GetUidData());
   }
 };
 
@@ -63,12 +61,12 @@ protected:
   GeometryShaderUid GetUid(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type,
                            API_TYPE api_type) override
   {
-    return GetGeometryShaderUid(primitive_type, api_type);
+    return GetGeometryShaderUid(primitive_type);
   }
-  ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type,
-                          API_TYPE api_type) override
+  ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, API_TYPE api_type,
+                          GeometryShaderUid uid) override
   {
-    return GenerateGeometryShaderCode(primitive_type, api_type);
+    return GenerateGeometryShaderCode(api_type, uid.GetUidData());
   }
 };
 
@@ -81,12 +79,12 @@ protected:
   PixelShaderUid GetUid(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type,
                         API_TYPE api_type) override
   {
-    return GetPixelShaderUid(dst_alpha_mode, api_type);
+    return GetPixelShaderUid(dst_alpha_mode);
   }
-  ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, u32 primitive_type,
-                          API_TYPE api_type) override
+  ShaderCode GenerateCode(DSTALPHA_MODE dst_alpha_mode, API_TYPE api_type,
+                          PixelShaderUid uid) override
   {
-    return GeneratePixelShaderCode(dst_alpha_mode, api_type);
+    return GeneratePixelShaderCode(dst_alpha_mode, api_type, uid.GetUidData());
   }
 };
 
diff --git a/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp b/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
index 9ec9684224..58bd6c2a7b 100644
--- a/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
+++ b/Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
@@ -36,9 +36,6 @@ static GLuint CurrentProgram = 0;
 ProgramShaderCache::PCache ProgramShaderCache::pshaders;
 ProgramShaderCache::PCacheEntry* ProgramShaderCache::last_entry;
 SHADERUID ProgramShaderCache::last_uid;
-UidChecker<PixelShaderUid, ShaderCode> ProgramShaderCache::pixel_uid_checker;
-UidChecker<VertexShaderUid, ShaderCode> ProgramShaderCache::vertex_uid_checker;
-UidChecker<GeometryShaderUid, ShaderCode> ProgramShaderCache::geometry_uid_checker;
 
 static std::string s_glsl_header = "";
 
@@ -209,19 +206,12 @@ SHADER* ProgramShaderCache::SetShader(DSTALPHA_MODE dstAlphaMode, u32 primitive_
   last_entry = &newentry;
   newentry.in_cache = 0;
 
-  ShaderCode vcode = GenerateVertexShaderCode(API_OPENGL);
-  ShaderCode pcode = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL);
+  ShaderCode vcode = GenerateVertexShaderCode(API_OPENGL, uid.vuid.GetUidData());
+  ShaderCode pcode = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL, uid.puid.GetUidData());
   ShaderCode gcode;
   if (g_ActiveConfig.backend_info.bSupportsGeometryShaders &&
       !uid.guid.GetUidData()->IsPassthrough())
-    gcode = GenerateGeometryShaderCode(primitive_type, API_OPENGL);
-
-  if (g_ActiveConfig.bEnableShaderDebugging)
-  {
-    newentry.shader.strvprog = vcode.GetBuffer();
-    newentry.shader.strpprog = pcode.GetBuffer();
-    newentry.shader.strgprog = gcode.GetBuffer();
-  }
+    gcode = GenerateGeometryShaderCode(API_OPENGL, uid.guid.GetUidData());
 
 #if defined(_DEBUG) || defined(DEBUGFAST)
   if (g_ActiveConfig.iLog & CONF_SAVESHADERS)
@@ -397,21 +387,9 @@ GLuint ProgramShaderCache::CompileSingleShader(GLuint type, const std::string& c
 
 void ProgramShaderCache::GetShaderId(SHADERUID* uid, DSTALPHA_MODE dstAlphaMode, u32 primitive_type)
 {
-  uid->puid = GetPixelShaderUid(dstAlphaMode, API_OPENGL);
-  uid->vuid = GetVertexShaderUid(API_OPENGL);
-  uid->guid = GetGeometryShaderUid(primitive_type, API_OPENGL);
-
-  if (g_ActiveConfig.bEnableShaderDebugging)
-  {
-    ShaderCode pcode = GeneratePixelShaderCode(dstAlphaMode, API_OPENGL);
-    pixel_uid_checker.AddToIndexAndCheck(pcode, uid->puid, "Pixel", "p");
-
-    ShaderCode vcode = GenerateVertexShaderCode(API_OPENGL);
-    vertex_uid_checker.AddToIndexAndCheck(vcode, uid->vuid, "Vertex", "v");
-
-    ShaderCode gcode = GenerateGeometryShaderCode(primitive_type, API_OPENGL);
-    geometry_uid_checker.AddToIndexAndCheck(gcode, uid->guid, "Geometry", "g");
-  }
+  uid->puid = GetPixelShaderUid(dstAlphaMode);
+  uid->vuid = GetVertexShaderUid();
+  uid->guid = GetGeometryShaderUid(primitive_type);
 }
 
 ProgramShaderCache::PCacheEntry ProgramShaderCache::GetShaderProgram()
@@ -436,7 +414,7 @@ void ProgramShaderCache::Init()
   s_buffer = StreamBuffer::Create(GL_UNIFORM_BUFFER, UBO_LENGTH);
 
   // Read our shader cache, only if supported
-  if (g_ogl_config.bSupportsGLSLCache && !g_Config.bEnableShaderDebugging)
+  if (g_ogl_config.bSupportsGLSLCache)
   {
     GLint Supported;
     glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &Supported);
@@ -470,7 +448,7 @@ void ProgramShaderCache::Init()
 void ProgramShaderCache::Shutdown()
 {
   // store all shaders in cache on disk
-  if (g_ogl_config.bSupportsGLSLCache && !g_Config.bEnableShaderDebugging)
+  if (g_ogl_config.bSupportsGLSLCache)
   {
     for (auto& entry : pshaders)
     {
@@ -516,9 +494,6 @@ void ProgramShaderCache::Shutdown()
   }
   pshaders.clear();
 
-  pixel_uid_checker.Invalidate();
-  vertex_uid_checker.Invalidate();
-
   s_buffer.reset();
 }
 
diff --git a/Source/Core/VideoBackends/OGL/ProgramShaderCache.h b/Source/Core/VideoBackends/OGL/ProgramShaderCache.h
index 4852d71b86..4c97da20e2 100644
--- a/Source/Core/VideoBackends/OGL/ProgramShaderCache.h
+++ b/Source/Core/VideoBackends/OGL/ProgramShaderCache.h
@@ -88,10 +88,6 @@ private:
   static PCacheEntry* last_entry;
   static SHADERUID last_uid;
 
-  static UidChecker<PixelShaderUid, ShaderCode> pixel_uid_checker;
-  static UidChecker<VertexShaderUid, ShaderCode> vertex_uid_checker;
-  static UidChecker<GeometryShaderUid, ShaderCode> geometry_uid_checker;
-
   static u32 s_ubo_buffer_size;
   static s32 s_ubo_align;
 };