Reuse sampler descriptor set allocations in Vulkan

src/gpu/vk/GrVkPipelineStateBuilder.cpp

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "vk/GrVkPipelineStateBuilder.h"
 
+#include "vk/GrVkDescriptorSetManager.h"
 #include "vk/GrVkGpu.h"
 #include "vk/GrVkRenderPass.h"
 #if USE_SKSL
 #include "SkSLCompiler.h"
 #endif
 
 GrVkPipelineState* GrVkPipelineStateBuilder::CreatePipelineState(
                                                                GrVkGpu* gpu,
                                                                const GrPipeline& pipeline,
                                                                const GrPrimitiveProcessor& primProc,
@@ skipping 33 matching lines @@
 }
 
 void GrVkPipelineStateBuilder::finalizeFragmentOutputColor(GrGLSLShaderVar& outputColor) {
     outputColor.setLayoutQualifier("location = 0, index = 0");
 }
 
 void GrVkPipelineStateBuilder::finalizeFragmentSecondaryColor(GrGLSLShaderVar& outputColor) {
     outputColor.setLayoutQualifier("location = 0, index = 1");
 }
 
-VkShaderStageFlags visibility_to_vk_stage_flags(uint32_t visibility) {
-    VkShaderStageFlags flags = 0;
-
-    if (visibility & kVertex_GrShaderFlag) {
-        flags |= VK_SHADER_STAGE_VERTEX_BIT;
-    }
-    if (visibility & kGeometry_GrShaderFlag) {
-        flags |= VK_SHADER_STAGE_GEOMETRY_BIT;
-    }
-    if (visibility & kFragment_GrShaderFlag) {
-        flags |= VK_SHADER_STAGE_FRAGMENT_BIT;
-    }
-    return flags;
-}
-
 #if USE_SKSL
 SkSL::Program::Kind vk_shader_stage_to_skiasl_kind(VkShaderStageFlagBits stage) {
     if (VK_SHADER_STAGE_VERTEX_BIT == stage) {
         return SkSL::Program::kVertex_Kind;
     }
     SkASSERT(VK_SHADER_STAGE_FRAGMENT_BIT == stage);
     return SkSL::Program::kFragment_Kind;
 }
 #else
 shaderc_shader_kind vk_shader_stage_to_shaderc_kind(VkShaderStageFlagBits stage) {
@@ skipping 31 matching lines @@
 #else
     shaderc_compilation_result_t result = nullptr;
 #endif
 
     if (gpu->vkCaps().canUseGLSLForShaderModule()) {
         moduleCreateInfo.codeSize = strlen(shaderString.c_str());
         moduleCreateInfo.pCode = (const uint32_t*)shaderString.c_str();
     } else {
 
 #if USE_SKSL
-        bool result = gpu->shaderCompiler()->toSPIRV(vk_shader_stage_to_skiasl_kind(stage), 
+        bool result = gpu->shaderCompiler()->toSPIRV(vk_shader_stage_to_skiasl_kind(stage),
                                                      std::string(shaderString.c_str()),
                                                      &code);
         if (!result) {
             SkDebugf("%s\n", gpu->shaderCompiler()->errorText().c_str());
             return false;
         }
         moduleCreateInfo.codeSize = code.size();
         moduleCreateInfo.pCode = (const uint32_t*) code.c_str();
 #else
         shaderc_compiler_t compiler = gpu->shadercCompiler();
@@ skipping 49 matching lines @@
 }
 
 GrVkPipelineState* GrVkPipelineStateBuilder::finalize(GrPrimitiveType primitiveType,
                                                       const GrVkRenderPass& renderPass,
                                                       const GrVkPipelineState::Desc& desc) {
     VkDescriptorSetLayout dsLayout[2];
     VkPipelineLayout pipelineLayout;
     VkShaderModule vertShaderModule;
     VkShaderModule fragShaderModule;
 
-    uint32_t numSamplers = (uint32_t)fUniformHandler.numSamplers();
+    GrVkResourceProvider& resourceProvider = fGpu->resourceProvider();
+    // This layout is not owned by the PipelineStateBuilder and thus should no be destroyed
+    dsLayout[GrVkUniformHandler::kUniformBufferDescSet] = resourceProvider.getUniformDSLayout();
 
-    SkAutoTDeleteArray<VkDescriptorSetLayoutBinding> dsSamplerBindings(
-                                                     new VkDescriptorSetLayoutBinding[numSamplers]);
-    for (uint32_t i = 0; i < numSamplers; ++i) {
-        const GrVkGLSLSampler& sampler =
-            static_cast<const GrVkGLSLSampler&>(fUniformHandler.getSampler(i));
-        SkASSERT(sampler.binding() == i);
-        dsSamplerBindings[i].binding = sampler.binding();
-        dsSamplerBindings[i].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-        dsSamplerBindings[i].descriptorCount = 1;
-        dsSamplerBindings[i].stageFlags = visibility_to_vk_stage_flags(sampler.visibility());
-        dsSamplerBindings[i].pImmutableSamplers = nullptr;
-    }
-
-    VkDescriptorSetLayoutCreateInfo dsSamplerLayoutCreateInfo;
-    memset(&dsSamplerLayoutCreateInfo, 0, sizeof(VkDescriptorSetLayoutCreateInfo));
-    dsSamplerLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-    dsSamplerLayoutCreateInfo.pNext = nullptr;
-    dsSamplerLayoutCreateInfo.flags = 0;
-    dsSamplerLayoutCreateInfo.bindingCount = numSamplers;
-    // Setting to nullptr fixes an error in the param checker validation layer. Even though
-    // bindingCount is 0 (which is valid), it still tries to validate pBindings unless it is null.
-    dsSamplerLayoutCreateInfo.pBindings = numSamplers ? dsSamplerBindings.get() : nullptr;
-
-    GR_VK_CALL_ERRCHECK(fGpu->vkInterface(),
-                        CreateDescriptorSetLayout(fGpu->device(),
-                                                  &dsSamplerLayoutCreateInfo,
-                                                  nullptr,
-                                                  &dsLayout[GrVkUniformHandler::kSamplerDescSet]));
-
-    // This layout is not owned by the PipelineStateBuilder and thus should no be destroyed
-    dsLayout[GrVkUniformHandler::kUniformBufferDescSet] = fGpu->resourceProvider().getUniDSLayout();
+    GrVkDescriptorSetManager::Handle samplerDSHandle;
+    resourceProvider.getSamplerDescriptorSetHandle(fUniformHandler, &samplerDSHandle);
+    dsLayout[GrVkUniformHandler::kSamplerDescSet] =
+            resourceProvider.getSamplerDSLayout(samplerDSHandle);
 
     // Create the VkPipelineLayout
     VkPipelineLayoutCreateInfo layoutCreateInfo;
     memset(&layoutCreateInfo, 0, sizeof(VkPipelineLayoutCreateFlags));
     layoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
     layoutCreateInfo.pNext = 0;
     layoutCreateInfo.flags = 0;
     layoutCreateInfo.setLayoutCount = 2;
     layoutCreateInfo.pSetLayouts = dsLayout;
     layoutCreateInfo.pushConstantRangeCount = 0;
@@ skipping 19 matching lines @@
                                         fVS,
                                         &vertShaderModule,
                                         &shaderStageInfo[0]));
 
     SkAssertResult(CreateVkShaderModule(fGpu,
                                         VK_SHADER_STAGE_FRAGMENT_BIT,
                                         fFS,
                                         &fragShaderModule,
                                         &shaderStageInfo[1]));
 
-    GrVkResourceProvider& resourceProvider = fGpu->resourceProvider();
     GrVkPipeline* pipeline = resourceProvider.createPipeline(fPipeline,
                                                              fPrimProc,
                                                              shaderStageInfo,
                                                              2,
                                                              primitiveType,
                                                              renderPass,
                                                              pipelineLayout);
     GR_VK_CALL(fGpu->vkInterface(), DestroyShaderModule(fGpu->device(), vertShaderModule,
                                                         nullptr));
     GR_VK_CALL(fGpu->vkInterface(), DestroyShaderModule(fGpu->device(), fragShaderModule,
                                                         nullptr));
 
     if (!pipeline) {
         GR_VK_CALL(fGpu->vkInterface(), DestroyPipelineLayout(fGpu->device(), pipelineLayout,
                                                               nullptr));
         GR_VK_CALL(fGpu->vkInterface(),
                    DestroyDescriptorSetLayout(fGpu->device(),
                                               dsLayout[GrVkUniformHandler::kSamplerDescSet],
                                               nullptr));
 
         this->cleanupFragmentProcessors();
         return nullptr;
     }
 
     return new GrVkPipelineState(fGpu,
                                  desc,
                                  pipeline,
                                  pipelineLayout,
-                                 dsLayout[GrVkUniformHandler::kSamplerDescSet],
+                                 samplerDSHandle,
                                  fUniformHandles,
                                  fUniformHandler.fUniforms,
                                  fUniformHandler.fCurrentVertexUBOOffset,
                                  fUniformHandler.fCurrentFragmentUBOOffset,
-                                 numSamplers,
+                                 (uint32_t)fUniformHandler.numSamplers(),
                                  fGeometryProcessor,
                                  fXferProcessor,
                                  fFragmentProcessors);
 }
+