Move histogram/minmax shaders into vulkan shader cache

* This lets us cache all shaders instead of having some be regenerated outside
  the cache and looked up into it.

renderdoc/data/glsl/glsl_globals.h

@@ -174,3 +174,29 @@ vec3 CalcCubeCoord(vec2 uv, int face)
 #define MESH_TRIANGLE_FAN 3u
 #define MESH_TRIANGLE_LIST_ADJ 4u
 #define MESH_TRIANGLE_STRIP_ADJ 5u
+
+#if defined(SHADER_BASETYPE) && SHADER_BASETYPE == 0
+
+#define FLOAT_TEX 1
+#define UINT_TEX 0
+#define SINT_TEX 0
+
+#elif defined(SHADER_BASETYPE) && SHADER_BASETYPE == 1
+
+#define FLOAT_TEX 0
+#define UINT_TEX 1
+#define SINT_TEX 0
+
+#elif defined(SHADER_BASETYPE) && SHADER_BASETYPE == 2
+
+#define FLOAT_TEX 0
+#define UINT_TEX 0
+#define SINT_TEX 1
+
+#else
+
+#define FLOAT_TEX 1
+#define UINT_TEX 0
+#define SINT_TEX 0
+
+#endif

renderdoc/data/hlsl/hlsl_cbuffers.h

@@ -218,3 +218,29 @@ cbuffer HistogramCBufferData REG(b0)
 #define MESH_TRIANGLE_STRIP 2
 #define MESH_TRIANGLE_LIST_ADJ 3
 #define MESH_TRIANGLE_STRIP_ADJ 4
+
+#if defined(SHADER_BASETYPE) && SHADER_BASETYPE == 0
+
+#define FLOAT_TEX 1
+#define UINT_TEX 0
+#define SINT_TEX 0
+
+#elif defined(SHADER_BASETYPE) && SHADER_BASETYPE == 1
+
+#define FLOAT_TEX 0
+#define UINT_TEX 1
+#define SINT_TEX 0
+
+#elif defined(SHADER_BASETYPE) && SHADER_BASETYPE == 2
+
+#define FLOAT_TEX 0
+#define UINT_TEX 0
+#define SINT_TEX 1
+
+#else
+
+#define FLOAT_TEX 1
+#define UINT_TEX 0
+#define SINT_TEX 0
+
+#endif

renderdoc/driver/d3d11/d3d11_debug.cpp

@@ -1558,8 +1558,7 @@ void D3D11Replay::HistogramMinMax::Init(WrappedID3D11Device *device)
     for(int i = 0; i < 3; i++)
     {
       rdcstr hlsl = rdcstr("#define SHADER_RESTYPE ") + ToStr(t) + "\n";
-      hlsl += rdcstr("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n";
-      hlsl += rdcstr("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n";
+      hlsl += rdcstr("#define SHADER_BASETYPE ") + ToStr(i) + "\n";
       hlsl += histogramhlsl;
 
       TileMinMaxCS[t][i] =

renderdoc/driver/d3d12/d3d12_debug.cpp

@@ -2016,8 +2016,7 @@ void D3D12Replay::HistogramMinMax::Init(WrappedID3D12Device *device, D3D12DebugM
         ID3DBlob *histogram = NULL;
 
         rdcstr hlsl = rdcstr("#define SHADER_RESTYPE ") + ToStr(t) + "\n";
-        hlsl += rdcstr("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n";
-        hlsl += rdcstr("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n";
+        hlsl += rdcstr("#define SHADER_BASETYPE ") + ToStr(i) + "\n";
         hlsl += histogramhlsl;
 
         shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_TileMinMaxCS",

renderdoc/driver/gl/gl_debug.cpp

@@ -458,8 +458,7 @@ void GLReplay::InitDebugData()
 
   for(int i = 0; i < 3; i++)
   {
-    rdcstr defines = rdcstr("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n";
-    defines += rdcstr("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n";
+    rdcstr defines = rdcstr("#define SHADER_BASETYPE ") + ToStr(i) + "\n";
 
     fs = GenerateGLSLShader(GetEmbeddedResource(glsl_texdisplay_frag), shaderType, glslBaseVer,
                             defines + texSampleDefines);
@@ -840,8 +839,7 @@ void GLReplay::InitDebugData()
           {
             rdcstr defines;
             defines += rdcstr("#define SHADER_RESTYPE ") + ToStr(t) + "\n";
-            defines += rdcstr("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n";
-            defines += rdcstr("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n";
+            defines += rdcstr("#define SHADER_BASETYPE ") + ToStr(i) + "\n";
             defines += texSampleDefines;
 
             cs = GenerateGLSLShader(GetEmbeddedResource(glsl_minmaxtile_comp), shaderType,
@@ -856,8 +854,7 @@ void GLReplay::InitDebugData()
           {
             rdcstr defines;
             defines += rdcstr("#define SHADER_RESTYPE ") + ToStr(t) + "\n";
-            defines += rdcstr("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n";
-            defines += rdcstr("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n";
+            defines += rdcstr("#define SHADER_BASETYPE ") + ToStr(i) + "\n";
             defines += texSampleDefines;
 
             cs = GenerateGLSLShader(GetEmbeddedResource(glsl_histogram_comp), shaderType, glslCSVer,
@@ -873,8 +870,7 @@ void GLReplay::InitDebugData()
           {
             rdcstr defines;
             defines += rdcstr("#define SHADER_RESTYPE ") + ToStr(t) + "\n";
-            defines += rdcstr("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n";
-            defines += rdcstr("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n";
+            defines += rdcstr("#define SHADER_BASETYPE ") + ToStr(i) + "\n";
 
             cs = GenerateGLSLShader(GetEmbeddedResource(glsl_minmaxresult_comp), shaderType,
                                     glslCSVer, defines);

renderdoc/driver/vulkan/vk_debug.cpp

@@ -176,51 +176,6 @@ static void create(WrappedVulkan *driver, const char *objName, const int line, V
     RDCERR("Failed creating object %s at line %i, vkr was %s", objName, line, ToStr(vkr).c_str());
 }
 
-// Create a compute pipeline with a SPIRV Blob (creates a temporary shader module)
-static void create(WrappedVulkan *driver, const char *objName, const int line, VkPipeline *pipe,
-                   VkPipelineLayout pipeLayout, SPIRVBlob computeModule)
-{
-  *pipe = VK_NULL_HANDLE;
-
-  // if the module didn't compile, this pipeline is not be supported. Silently don't create it, code
-  // later should handle the missing pipeline as indicating lack of support
-  if(computeModule == NULL)
-    return;
-
-  VkShaderModule module = VK_NULL_HANDLE;
-
-  VkShaderModuleCreateInfo moduleInfo = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO};
-
-  moduleInfo.codeSize = computeModule->size() * sizeof(uint32_t);
-  moduleInfo.pCode = computeModule->data();
-
-  VkResult vkr = driver->vkCreateShaderModule(driver->GetDev(), &moduleInfo, NULL, &module);
-  if(vkr != VK_SUCCESS)
-  {
-    RDCERR("Failed creating temporary shader for object  %s at line %i, vkr was %s", objName, line,
-           ToStr(vkr).c_str());
-    return;
-  }
-
-  VkComputePipelineCreateInfo compPipeInfo = {
-      VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-      NULL,
-      0,
-      {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_COMPUTE_BIT,
-       module, "main", NULL},
-      pipeLayout,
-      VK_NULL_HANDLE,
-      0,
-  };
-
-  vkr = driver->vkCreateComputePipelines(driver->GetDev(), driver->GetShaderCache()->GetPipeCache(),
-                                         1, &compPipeInfo, NULL, pipe);
-  if(vkr != VK_SUCCESS)
-    RDCERR("Failed creating object %s at line %i, vkr was %s", objName, line, ToStr(vkr).c_str());
-
-  driver->vkDestroyShaderModule(driver->GetDev(), module, NULL);
-}
-
 static void create(WrappedVulkan *driver, const char *objName, const int line,
                    VkDescriptorSet *descSet, VkDescriptorPool pool, VkDescriptorSetLayout setLayout)
 {
@@ -3035,14 +2990,13 @@ void VulkanReplay::TextureRendering::Init(WrappedVulkan *driver, VkDescriptorPoo
     VkFormat formats[3] = {VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R16G16B16A16_UINT,
                            VK_FORMAT_R32G32B32A32_UINT};
     CompType cast[3] = {CompType::Float, CompType::UInt, CompType::SInt};
-    BuiltinShader shaders[3] = {BuiltinShader::TexRemapFloat, BuiltinShader::TexRemapUInt,
-                                BuiltinShader::TexRemapSInt};
 
     for(int f = 0; f < 3; f++)
     {
       for(int i = 0; i < 3; i++)
       {
-        texRemapInfo.fragment = shaderCache->GetBuiltinModule(shaders[i]);
+        texRemapInfo.fragment =
+            shaderCache->GetBuiltinModule(BuiltinShader::TexRemap, BuiltinShaderBaseType(i));
 
         CREATE_OBJECT(texRemapInfo.renderPass, GetViewCastedFormat(formats[f], cast[i]));
 
@@ -3059,7 +3013,8 @@ void VulkanReplay::TextureRendering::Init(WrappedVulkan *driver, VkDescriptorPoo
     {
       for(int i = 0; i < 3; i++)
       {
-        texRemapInfo.fragment = shaderCache->GetBuiltinModule(shaders[i]);
+        texRemapInfo.fragment =
+            shaderCache->GetBuiltinModule(BuiltinShader::TexRemap, BuiltinShaderBaseType(i));
 
         CREATE_OBJECT(texRemapInfo.renderPass, GetViewCastedFormat(formats[f], cast[i]));
 
@@ -3853,60 +3808,25 @@ void VulkanReplay::HistogramMinMax::Init(WrappedVulkan *driver, VkDescriptorPool
   RDCCOMPILE_ASSERT(RESTYPE_TEXTYPEMAX == ARRAY_COUNT(m_MinMaxTilePipe),
                     "RESTYPE values don't match formats for dummy images");
 
-  for(size_t t = 1; t < ARRAY_COUNT(m_MinMaxTilePipe); t++)
+  RDCCOMPILE_ASSERT(ARRAY_COUNT(m_MinMaxTilePipe) == arraydim<BuiltinShaderTextureType>(),
+                    "Array size doesn't match parameter enum");
+  RDCCOMPILE_ASSERT(ARRAY_COUNT(m_MinMaxTilePipe[0]) == arraydim<BuiltinShaderBaseType>(),
+                    "Array size doesn't match parameter enum");
+
+  for(BuiltinShaderTextureType t = BuiltinShaderTextureType::First;
+      t < BuiltinShaderTextureType::Count; ++t)
   {
-    for(size_t f = 0; f < ARRAY_COUNT(m_MinMaxTilePipe[0]); f++)
+    for(BuiltinShaderBaseType f = BuiltinShaderBaseType::First; f < BuiltinShaderBaseType::Count; ++f)
     {
-      SPIRVBlob minmaxtile = NULL;
-      SPIRVBlob minmaxresult = NULL;
-      SPIRVBlob histogram = NULL;
-      rdcstr err;
+      CREATE_OBJECT(m_HistogramPipe[(size_t)t][(size_t)f], m_HistogramPipeLayout,
+                    shaderCache->GetBuiltinModule(BuiltinShader::HistogramCS, f, t));
+      CREATE_OBJECT(m_MinMaxTilePipe[(size_t)t][(size_t)f], m_HistogramPipeLayout,
+                    shaderCache->GetBuiltinModule(BuiltinShader::MinMaxTileCS, f, t));
 
-      rdcstr defines = shaderCache->GetGlobalDefines();
-
-      defines += rdcstr("#define SHADER_RESTYPE ") + ToStr(t) + "\n";
-      defines += rdcstr("#define UINT_TEX ") + (f == 1 ? "1" : "0") + "\n";
-      defines += rdcstr("#define SINT_TEX ") + (f == 2 ? "1" : "0") + "\n";
-
-      glsl = GenerateGLSLShader(GetEmbeddedResource(glsl_histogram_comp), ShaderType::Vulkan, 430,
-                                defines);
-
-      err = shaderCache->GetSPIRVBlob(compileSettings, glsl, histogram);
-      if(!err.empty())
+      if(t == BuiltinShaderTextureType::First)
       {
-        RDCERR("Error compiling histogram shader: %s. Defines are:\n%s", err.c_str(),
-               defines.c_str());
-        histogram = NULL;
-      }
-
-      glsl = GenerateGLSLShader(GetEmbeddedResource(glsl_minmaxtile_comp), ShaderType::Vulkan, 430,
-                                defines);
-
-      err = shaderCache->GetSPIRVBlob(compileSettings, glsl, minmaxtile);
-      if(!err.empty())
-      {
-        RDCERR("Error compiling min/max tile shader: %s. Defines are:\n%s", err.c_str(),
-               defines.c_str());
-        minmaxtile = NULL;
-      }
-
-      CREATE_OBJECT(m_MinMaxTilePipe[t][f], m_HistogramPipeLayout, minmaxtile);
-      CREATE_OBJECT(m_HistogramPipe[t][f], m_HistogramPipeLayout, histogram);
-
-      if(t == 1)
-      {
-        glsl = GenerateGLSLShader(GetEmbeddedResource(glsl_minmaxresult_comp), ShaderType::Vulkan,
-                                  430, defines);
-
-        err = shaderCache->GetSPIRVBlob(compileSettings, glsl, minmaxresult);
-        if(!err.empty())
-        {
-          RDCERR("Error compiling min/max result shader: %s. Defines are:\n%s", err.c_str(),
-                 defines.c_str());
-          minmaxresult = NULL;
-        }
-
-        CREATE_OBJECT(m_MinMaxResultPipe[f], m_HistogramPipeLayout, minmaxresult);
+        CREATE_OBJECT(m_MinMaxResultPipe[(size_t)f], m_HistogramPipeLayout,
+                      shaderCache->GetBuiltinModule(BuiltinShader::MinMaxResultCS, f));
       }
     }
   }

renderdoc/driver/vulkan/vk_shader_cache.cpp

@@ -39,69 +39,98 @@ enum class FeatureCheck
 
 BITMASK_OPERATORS(FeatureCheck);
 
+enum class BuiltinShaderFlags
+{
+  None = 0x0,
+  BaseTypeParameterised = 0x1,
+  TextureTypeParameterised = 0x2,
+};
+
+BITMASK_OPERATORS(BuiltinShaderFlags);
+
 struct BuiltinShaderConfig
 {
+  BuiltinShaderConfig(BuiltinShader builtin, EmbeddedResourceType resource,
+                      rdcspv::ShaderStage stage, FeatureCheck checks = FeatureCheck::NoCheck,
+                      BuiltinShaderFlags flags = BuiltinShaderFlags::None)
+      : builtin(builtin), resource(resource), stage(stage), checks(checks), flags(flags)
+  {
+  }
   BuiltinShader builtin;
   EmbeddedResourceType resource;
   rdcspv::ShaderStage stage;
   FeatureCheck checks;
-  bool uniforms;
+  BuiltinShaderFlags flags;
 };
 
 static const BuiltinShaderConfig builtinShaders[] = {
-    {BuiltinShader::BlitVS, EmbeddedResource(glsl_blit_vert), rdcspv::ShaderStage::Vertex,
-     FeatureCheck::NoCheck, true},
-    {BuiltinShader::CheckerboardFS, EmbeddedResource(glsl_checkerboard_frag),
-     rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true},
-    {BuiltinShader::TexDisplayFS, EmbeddedResource(glsl_texdisplay_frag),
-     rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true},
-    {BuiltinShader::FixedColFS, EmbeddedResource(glsl_fixedcol_frag), rdcspv::ShaderStage::Fragment,
-     FeatureCheck::NoCheck, false},
-    {BuiltinShader::TextVS, EmbeddedResource(glsl_vktext_vert), rdcspv::ShaderStage::Vertex,
-     FeatureCheck::NoCheck, true},
-    {BuiltinShader::TextFS, EmbeddedResource(glsl_vktext_frag), rdcspv::ShaderStage::Fragment,
-     FeatureCheck::NoCheck, true},
-    {BuiltinShader::MeshVS, EmbeddedResource(glsl_mesh_vert), rdcspv::ShaderStage::Vertex,
-     FeatureCheck::NoCheck, true},
-    {BuiltinShader::MeshGS, EmbeddedResource(glsl_mesh_geom), rdcspv::ShaderStage::Geometry,
-     FeatureCheck::NoCheck, true},
-    {BuiltinShader::MeshFS, EmbeddedResource(glsl_mesh_frag), rdcspv::ShaderStage::Fragment,
-     FeatureCheck::NoCheck, true},
-    {BuiltinShader::MeshCS, EmbeddedResource(glsl_mesh_comp), rdcspv::ShaderStage::Compute,
-     FeatureCheck::NoCheck, true},
-    {BuiltinShader::QuadResolveFS, EmbeddedResource(glsl_quadresolve_frag),
-     rdcspv::ShaderStage::Fragment, FeatureCheck::FragmentStores, true},
-    {BuiltinShader::QuadWriteFS, EmbeddedResource(glsl_quadwrite_frag), rdcspv::ShaderStage::Fragment,
-     FeatureCheck::FragmentStores | FeatureCheck::NonMetalBackend, false},
-    {BuiltinShader::TrisizeGS, EmbeddedResource(glsl_trisize_geom), rdcspv::ShaderStage::Geometry,
-     FeatureCheck::NoCheck, true},
-    {BuiltinShader::TrisizeFS, EmbeddedResource(glsl_trisize_frag), rdcspv::ShaderStage::Fragment,
-     FeatureCheck::NoCheck, true},
-    {BuiltinShader::MS2ArrayCS, EmbeddedResource(glsl_ms2array_comp), rdcspv::ShaderStage::Compute,
-     FeatureCheck::FormatlessWrite | FeatureCheck::NonMetalBackend, true},
-    {BuiltinShader::Array2MSCS, EmbeddedResource(glsl_array2ms_comp), rdcspv::ShaderStage::Compute,
-     FeatureCheck::ShaderMSAAStorage | FeatureCheck::FormatlessWrite | FeatureCheck::NonMetalBackend,
-     true},
-    {BuiltinShader::DepthMS2ArrayFS, EmbeddedResource(glsl_depthms2arr_frag),
-     rdcspv::ShaderStage::Fragment, FeatureCheck::NonMetalBackend, true},
-    {BuiltinShader::DepthArray2MSFS, EmbeddedResource(glsl_deptharr2ms_frag),
-     rdcspv::ShaderStage::Fragment, FeatureCheck::SampleShading | FeatureCheck::NonMetalBackend, true},
-    {BuiltinShader::TexRemapFloat, EmbeddedResource(glsl_texremap_frag),
-     rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true},
-    {BuiltinShader::TexRemapUInt, EmbeddedResource(glsl_texremap_frag),
-     rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true},
-    {BuiltinShader::TexRemapSInt, EmbeddedResource(glsl_texremap_frag),
-     rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true},
-    {BuiltinShader::PixelHistoryMSCopyCS, EmbeddedResource(glsl_pixelhistory_mscopy_comp),
-     rdcspv::ShaderStage::Compute, FeatureCheck::NoCheck, true},
-    {BuiltinShader::PixelHistoryMSCopyDepthCS, EmbeddedResource(glsl_pixelhistory_mscopy_depth_comp),
-     rdcspv::ShaderStage::Compute, FeatureCheck::NoCheck, true},
-    {BuiltinShader::PixelHistoryPrimIDFS, EmbeddedResource(glsl_pixelhistory_primid_frag),
-     rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck, true},
-    {BuiltinShader::ShaderDebugSampleVS, EmbeddedResource(glsl_shaderdebug_sample_vert),
-     rdcspv::ShaderStage::Vertex, FeatureCheck::NoCheck, true},
-    {BuiltinShader::DiscardFS, EmbeddedResource(glsl_discard_frag), rdcspv::ShaderStage::Fragment,
-     FeatureCheck::NoCheck, true},
+    BuiltinShaderConfig(BuiltinShader::BlitVS, EmbeddedResource(glsl_blit_vert),
+                        rdcspv::ShaderStage::Vertex),
+    BuiltinShaderConfig(BuiltinShader::CheckerboardFS, EmbeddedResource(glsl_checkerboard_frag),
+                        rdcspv::ShaderStage::Fragment),
+    BuiltinShaderConfig(BuiltinShader::TexDisplayFS, EmbeddedResource(glsl_texdisplay_frag),
+                        rdcspv::ShaderStage::Fragment),
+    BuiltinShaderConfig(BuiltinShader::FixedColFS, EmbeddedResource(glsl_fixedcol_frag),
+                        rdcspv::ShaderStage::Fragment),
+    BuiltinShaderConfig(BuiltinShader::TextVS, EmbeddedResource(glsl_vktext_vert),
+                        rdcspv::ShaderStage::Vertex),
+    BuiltinShaderConfig(BuiltinShader::TextFS, EmbeddedResource(glsl_vktext_frag),
+                        rdcspv::ShaderStage::Fragment),
+    BuiltinShaderConfig(BuiltinShader::MeshVS, EmbeddedResource(glsl_mesh_vert),
+                        rdcspv::ShaderStage::Vertex),
+    BuiltinShaderConfig(BuiltinShader::MeshGS, EmbeddedResource(glsl_mesh_geom),
+                        rdcspv::ShaderStage::Geometry),
+    BuiltinShaderConfig(BuiltinShader::MeshFS, EmbeddedResource(glsl_mesh_frag),
+                        rdcspv::ShaderStage::Fragment),
+    BuiltinShaderConfig(BuiltinShader::MeshCS, EmbeddedResource(glsl_mesh_comp),
+                        rdcspv::ShaderStage::Compute),
+    BuiltinShaderConfig(BuiltinShader::QuadResolveFS, EmbeddedResource(glsl_quadresolve_frag),
+                        rdcspv::ShaderStage::Fragment, FeatureCheck::FragmentStores),
+    BuiltinShaderConfig(BuiltinShader::QuadWriteFS, EmbeddedResource(glsl_quadwrite_frag),
+                        rdcspv::ShaderStage::Fragment,
+                        FeatureCheck::FragmentStores | FeatureCheck::NonMetalBackend),
+    BuiltinShaderConfig(BuiltinShader::TrisizeGS, EmbeddedResource(glsl_trisize_geom),
+                        rdcspv::ShaderStage::Geometry),
+    BuiltinShaderConfig(BuiltinShader::TrisizeFS, EmbeddedResource(glsl_trisize_frag),
+                        rdcspv::ShaderStage::Fragment),
+    BuiltinShaderConfig(BuiltinShader::MS2ArrayCS, EmbeddedResource(glsl_ms2array_comp),
+                        rdcspv::ShaderStage::Compute,
+                        FeatureCheck::FormatlessWrite | FeatureCheck::NonMetalBackend),
+    BuiltinShaderConfig(BuiltinShader::Array2MSCS, EmbeddedResource(glsl_array2ms_comp),
+                        rdcspv::ShaderStage::Compute,
+                        FeatureCheck::ShaderMSAAStorage | FeatureCheck::FormatlessWrite |
+                            FeatureCheck::NonMetalBackend),
+    BuiltinShaderConfig(BuiltinShader::DepthMS2ArrayFS, EmbeddedResource(glsl_depthms2arr_frag),
+                        rdcspv::ShaderStage::Fragment, FeatureCheck::NonMetalBackend),
+    BuiltinShaderConfig(BuiltinShader::DepthArray2MSFS, EmbeddedResource(glsl_deptharr2ms_frag),
+                        rdcspv::ShaderStage::Fragment,
+                        FeatureCheck::SampleShading | FeatureCheck::NonMetalBackend),
+    BuiltinShaderConfig(BuiltinShader::TexRemap, EmbeddedResource(glsl_texremap_frag),
+                        rdcspv::ShaderStage::Fragment, FeatureCheck::NoCheck,
+                        BuiltinShaderFlags::BaseTypeParameterised),
+    BuiltinShaderConfig(BuiltinShader::PixelHistoryMSCopyCS,
+                        EmbeddedResource(glsl_pixelhistory_mscopy_comp), rdcspv::ShaderStage::Compute),
+    BuiltinShaderConfig(BuiltinShader::PixelHistoryMSCopyDepthCS,
+                        EmbeddedResource(glsl_pixelhistory_mscopy_depth_comp),
+                        rdcspv::ShaderStage::Compute),
+    BuiltinShaderConfig(BuiltinShader::PixelHistoryPrimIDFS,
+                        EmbeddedResource(glsl_pixelhistory_primid_frag),
+                        rdcspv::ShaderStage::Fragment),
+    BuiltinShaderConfig(BuiltinShader::ShaderDebugSampleVS,
+                        EmbeddedResource(glsl_shaderdebug_sample_vert), rdcspv::ShaderStage::Vertex),
+    BuiltinShaderConfig(BuiltinShader::DiscardFS, EmbeddedResource(glsl_discard_frag),
+                        rdcspv::ShaderStage::Fragment),
+    BuiltinShaderConfig(
+        BuiltinShader::HistogramCS, EmbeddedResource(glsl_histogram_comp),
+        rdcspv::ShaderStage::Compute, FeatureCheck::NoCheck,
+        BuiltinShaderFlags::BaseTypeParameterised | BuiltinShaderFlags::TextureTypeParameterised),
+    BuiltinShaderConfig(
+        BuiltinShader::MinMaxTileCS, EmbeddedResource(glsl_minmaxtile_comp),
+        rdcspv::ShaderStage::Compute, FeatureCheck::NoCheck,
+        BuiltinShaderFlags::BaseTypeParameterised | BuiltinShaderFlags::TextureTypeParameterised),
+    BuiltinShaderConfig(BuiltinShader::MinMaxResultCS, EmbeddedResource(glsl_minmaxresult_comp),
+                        rdcspv::ShaderStage::Compute, FeatureCheck::NoCheck,
+                        BuiltinShaderFlags::BaseTypeParameterised),
 };
 
 RDCCOMPILE_ASSERT(ARRAY_COUNT(builtinShaders) == arraydim<BuiltinShader>(),
@@ -204,11 +233,11 @@ VulkanShaderCache::VulkanShaderCache(WrappedVulkan *driver)
   const VkPhysicalDeviceFeatures &enabledFeatures = driver->GetDeviceEnabledFeatures();
   const VkPhysicalDeviceFeatures &availFeatures = driver->GetDeviceAvailableFeatures();
 
-  m_GlobalDefines = "#define HAS_BIT_CONVERSION 1\n";
+  rdcstr globalDefines = "#define HAS_BIT_CONVERSION 1\n";
   if(driverVersion.TexelFetchBrokenDriver())
-    m_GlobalDefines += "#define NO_TEXEL_FETCH\n";
+    globalDefines += "#define NO_TEXEL_FETCH\n";
   if(driverVersion.RunningOnMetal())
-    m_GlobalDefines += "#define METAL_BACKEND\n";
+    globalDefines += "#define METAL_BACKEND\n";
 
   rdcstr src;
   rdcspv::CompilationSettings compileSettings;
@@ -230,40 +259,56 @@ VulkanShaderCache::VulkanShaderCache(WrappedVulkan *driver)
     if(!passesChecks)
       continue;
 
-    rdcstr defines = m_GlobalDefines;
+    size_t baseTypeCount = size_t(BuiltinShaderBaseType::First) + 1,
+           textureTypeCount = size_t(BuiltinShaderTextureType::First) + 1;
 
-    if(config.builtin == BuiltinShader::TexRemapFloat)
-      defines += rdcstr("#define UINT_TEX 0\n#define SINT_TEX 0\n");
-    else if(config.builtin == BuiltinShader::TexRemapUInt)
-      defines += rdcstr("#define UINT_TEX 1\n#define SINT_TEX 0\n");
-    else if(config.builtin == BuiltinShader::TexRemapSInt)
-      defines += rdcstr("#define UINT_TEX 0\n#define SINT_TEX 1\n");
+    if(config.flags & BuiltinShaderFlags::BaseTypeParameterised)
+      baseTypeCount = (size_t)BuiltinShaderBaseType::Count;
+    if(config.flags & BuiltinShaderFlags::TextureTypeParameterised)
+      textureTypeCount = (size_t)BuiltinShaderTextureType::Count;
 
-    src = GenerateGLSLShader(GetDynamicEmbeddedResource(config.resource), ShaderType::Vulkan, 430,
-                             defines);
-
-    compileSettings.stage = config.stage;
-    rdcstr err = GetSPIRVBlob(compileSettings, src, m_BuiltinShaderBlobs[i]);
-
-    if(!err.empty() || m_BuiltinShaderBlobs[i] == VK_NULL_HANDLE)
+    // for shaders that aren't parameterised these loops will be a no-op that only iterates once,
+    // and fills in [First][First] entry.
+    for(size_t baseType = (size_t)BuiltinShaderBaseType::First; baseType < baseTypeCount; baseType++)
     {
-      RDCERR("Error compiling builtin %u: %s", (uint32_t)i, err.c_str());
-    }
-    else
-    {
-      VkShaderModuleCreateInfo modinfo = {
-          VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
-          NULL,
-          0,
-          m_BuiltinShaderBlobs[i]->size() * sizeof(uint32_t),
-          m_BuiltinShaderBlobs[i]->data(),
-      };
+      for(size_t textureType = (size_t)BuiltinShaderTextureType::First;
+          textureType < textureTypeCount; textureType++)
+      {
+        rdcstr defines = globalDefines;
 
-      VkResult vkr =
-          driver->vkCreateShaderModule(m_Device, &modinfo, NULL, &m_BuiltinShaderModules[i]);
-      RDCASSERTEQUAL(vkr, VK_SUCCESS);
+        defines += rdcstr("#define SHADER_RESTYPE ") + ToStr(textureType) + "\n";
+        defines += rdcstr("#define SHADER_BASETYPE ") + ToStr(baseType) + "\n";
 
-      driver->GetResourceManager()->SetInternalResource(GetResID(m_BuiltinShaderModules[i]));
+        src = GenerateGLSLShader(GetDynamicEmbeddedResource(config.resource), ShaderType::Vulkan,
+                                 430, defines);
+
+        compileSettings.stage = config.stage;
+        rdcstr err =
+            GetSPIRVBlob(compileSettings, src, m_BuiltinShaderBlobs[i][baseType][textureType]);
+
+        if(!err.empty() || m_BuiltinShaderBlobs[i][baseType][textureType] == VK_NULL_HANDLE)
+        {
+          RDCERR("Error compiling builtin %u (baseType %zu textureType %zu): %s", (uint32_t)i,
+                 baseType, textureType, err.c_str());
+        }
+        else
+        {
+          VkShaderModuleCreateInfo modinfo = {
+              VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
+              NULL,
+              0,
+              m_BuiltinShaderBlobs[i][baseType][textureType]->size() * sizeof(uint32_t),
+              m_BuiltinShaderBlobs[i][baseType][textureType]->data(),
+          };
+
+          VkResult vkr = driver->vkCreateShaderModule(
+              m_Device, &modinfo, NULL, &m_BuiltinShaderModules[i][baseType][textureType]);
+          RDCASSERTEQUAL(vkr, VK_SUCCESS);
+
+          driver->GetResourceManager()->SetInternalResource(
+              GetResID(m_BuiltinShaderModules[i][baseType][textureType]));
+        }
+      }
     }
   }
 
@@ -370,7 +415,9 @@ VulkanShaderCache::~VulkanShaderCache()
   }
 
   for(size_t i = 0; i < ARRAY_COUNT(m_BuiltinShaderModules); i++)
-    m_pDriver->vkDestroyShaderModule(m_Device, m_BuiltinShaderModules[i], NULL);
+    for(size_t b = 0; b < ARRAY_COUNT(m_BuiltinShaderModules[0]); b++)
+      for(size_t t = 0; t < ARRAY_COUNT(m_BuiltinShaderModules[0][0]); t++)
+        m_pDriver->vkDestroyShaderModule(m_Device, m_BuiltinShaderModules[i][b][t], NULL);
 }
 
 rdcstr VulkanShaderCache::GetSPIRVBlob(const rdcspv::CompilationSettings &settings,

renderdoc/driver/vulkan/vk_shader_cache.h

@@ -51,19 +51,43 @@ enum class BuiltinShader
   Array2MSCS,
   DepthMS2ArrayFS,
   DepthArray2MSFS,
-  TexRemapFloat,
-  TexRemapUInt,
-  TexRemapSInt,
+  TexRemap,
   PixelHistoryMSCopyCS,
   PixelHistoryMSCopyDepthCS,
   PixelHistoryPrimIDFS,
   ShaderDebugSampleVS,
   DiscardFS,
+  HistogramCS,
+  MinMaxTileCS,
+  MinMaxResultCS,
   Count,
 };
 
 ITERABLE_OPERATORS(BuiltinShader);
 
+enum class BuiltinShaderBaseType
+{
+  Float = 0,
+  First = Float,
+  UInt,
+  SInt,
+  Count,
+};
+
+ITERABLE_OPERATORS(BuiltinShaderBaseType);
+
+enum class BuiltinShaderTextureType
+{
+  Tex1D = 1,
+  First = Tex1D,
+  Tex2D,
+  Tex3D,
+  Tex2DMS,
+  Count,
+};
+
+ITERABLE_OPERATORS(BuiltinShaderTextureType);
+
 class VulkanShaderCache
 {
 public:
@@ -73,10 +97,16 @@ public:
   rdcstr GetSPIRVBlob(const rdcspv::CompilationSettings &settings, const rdcstr &src,
                       SPIRVBlob &outBlob);
 
-  SPIRVBlob GetBuiltinBlob(BuiltinShader builtin) { return m_BuiltinShaderBlobs[(size_t)builtin]; }
-  VkShaderModule GetBuiltinModule(BuiltinShader builtin)
+  SPIRVBlob GetBuiltinBlob(BuiltinShader builtin)
   {
-    return m_BuiltinShaderModules[(size_t)builtin];
+    return m_BuiltinShaderBlobs[(size_t)builtin][(size_t)BuiltinShaderBaseType::First]
+                               [(size_t)BuiltinShaderTextureType::First];
+  }
+  VkShaderModule GetBuiltinModule(BuiltinShader builtin,
+                                  BuiltinShaderBaseType baseType = BuiltinShaderBaseType::First,
+                                  BuiltinShaderTextureType texType = BuiltinShaderTextureType::First)
+  {
+    return m_BuiltinShaderModules[(size_t)builtin][(size_t)baseType][(size_t)texType];
   }
   VkPipelineCache GetPipeCache() { return m_PipelineCache; }
   void MakeGraphicsPipelineInfo(VkGraphicsPipelineCreateInfo &pipeCreateInfo, ResourceId pipeline);
@@ -84,7 +114,6 @@ public:
 
   bool IsMS2ArraySupported() { return m_MS2ArraySupported; }
   bool IsArray2MSSupported() { return m_Array2MSSupported; }
-  rdcstr GetGlobalDefines() { return m_GlobalDefines; }
   void SetCaching(bool enabled) { m_CacheShaders = enabled; }
 private:
   static const uint32_t m_ShaderCacheMagic = 0xf00d00d5;
@@ -99,13 +128,13 @@ private:
   bytebuf m_PipeCacheBlob;
   VkPipelineCache m_PipelineCache = VK_NULL_HANDLE;
 
-  rdcstr m_GlobalDefines;
-
   bool m_MS2ArraySupported = false, m_Array2MSSupported = false;
 
   bool m_ShaderCacheDirty = false, m_CacheShaders = false;
   std::map<uint32_t, SPIRVBlob> m_ShaderCache;
 
-  SPIRVBlob m_BuiltinShaderBlobs[arraydim<BuiltinShader>()] = {NULL};
-  VkShaderModule m_BuiltinShaderModules[arraydim<BuiltinShader>()] = {VK_NULL_HANDLE};
+  SPIRVBlob m_BuiltinShaderBlobs[arraydim<BuiltinShader>()][arraydim<BuiltinShaderBaseType>()]
+                                [arraydim<BuiltinShaderTextureType>()] = {};
+  VkShaderModule m_BuiltinShaderModules[arraydim<BuiltinShader>()][arraydim<BuiltinShaderBaseType>()]
+                                       [arraydim<BuiltinShaderTextureType>()] = {};
 };