Set up cache in vulkan to reuse GrVkPrograms (aka VkPipelines)

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/GrVkProgramBuilder.h"
+#include "vk/GrVkPipelineStateBuilder.h"
 
 #include "vk/GrVkGpu.h"
 #include "vk/GrVkRenderPass.h"
-#include "vk/GrVkProgram.h"
 
-GrVkProgram* GrVkProgramBuilder::CreateProgram(GrVkGpu* gpu,
-                                               const GrPipeline& pipeline,
-                                               const GrPrimitiveProcessor& primProc,
-                                               GrPrimitiveType primitiveType,
-                                               const GrVkProgramDesc& desc,
-                                               const GrVkRenderPass& renderPass) {
+GrVkPipelineState* GrVkPipelineStateBuilder::CreatePipelineState(
+                                                               GrVkGpu* gpu,
+                                                               const GrPipeline& pipeline,
+                                                               const GrPrimitiveProcessor& primProc,
+                                                               GrPrimitiveType primitiveType,
+                                                               const GrVkPipelineState::Desc& desc,
+                                                               const GrVkRenderPass& renderPass) {
     // create a builder.  This will be handed off to effects so they can use it to add
     // uniforms, varyings, textures, etc
-    GrVkProgramBuilder builder(gpu, pipeline, primProc, desc);
+    GrVkPipelineStateBuilder builder(gpu, pipeline, primProc, desc.fProgramDesc);
 
     GrGLSLExpr4 inputColor;
     GrGLSLExpr4 inputCoverage;
 
     if (!builder.emitAndInstallProcs(&inputColor, &inputCoverage)) {
         builder.cleanupFragmentProcessors();
         return nullptr;
     }
 
-    return builder.finalize(primitiveType, renderPass);
+    return builder.finalize(primitiveType, renderPass, desc);
 }
 
-GrVkProgramBuilder::GrVkProgramBuilder(GrVkGpu* gpu,
-                                       const GrPipeline& pipeline,
-                                       const GrPrimitiveProcessor& primProc,
-                                       const GrVkProgramDesc& desc)
+GrVkPipelineStateBuilder::GrVkPipelineStateBuilder(GrVkGpu* gpu,
+                                                   const GrPipeline& pipeline,
+                                                   const GrPrimitiveProcessor& primProc,
+                                                   const GrVkProgramDesc& desc)
     : INHERITED(pipeline, primProc, desc) 
     , fGpu(gpu)
     , fVaryingHandler(this) 
     , fUniformHandler(this) {
 }
 
-const GrCaps* GrVkProgramBuilder::caps() const {
+const GrCaps* GrVkPipelineStateBuilder::caps() const {
     return fGpu->caps();
 }
-const GrGLSLCaps* GrVkProgramBuilder::glslCaps() const {
+const GrGLSLCaps* GrVkPipelineStateBuilder::glslCaps() const {
     return fGpu->vkCaps().glslCaps();
 }
 
-void GrVkProgramBuilder::finalizeFragmentOutputColor(GrGLSLShaderVar& outputColor) {
+void GrVkPipelineStateBuilder::finalizeFragmentOutputColor(GrGLSLShaderVar& outputColor) {
     outputColor.setLayoutQualifier("location = 0");
 }
 
 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;
 }
 
 shaderc_shader_kind vk_shader_stage_to_shaderc_kind(VkShaderStageFlagBits stage) {
     if (VK_SHADER_STAGE_VERTEX_BIT == stage) {
         return shaderc_glsl_vertex_shader;
     }
     SkASSERT(VK_SHADER_STAGE_FRAGMENT_BIT == stage);
     return shaderc_glsl_fragment_shader;
 }
 
-bool GrVkProgramBuilder::CreateVkShaderModule(const GrVkGpu* gpu,
-                                              VkShaderStageFlagBits stage,
-                                              const GrGLSLShaderBuilder& builder,
-                                              VkShaderModule* shaderModule,
-                                              VkPipelineShaderStageCreateInfo* stageInfo) {
+bool GrVkPipelineStateBuilder::CreateVkShaderModule(const GrVkGpu* gpu,
+                                                    VkShaderStageFlagBits stage,
+                                                    const GrGLSLShaderBuilder& builder,
+                                                    VkShaderModule* shaderModule,
+                                                    VkPipelineShaderStageCreateInfo* stageInfo) {
     SkString shaderString;
     for (int i = 0; i < builder.fCompilerStrings.count(); ++i) {
         if (builder.fCompilerStrings[i]) {
             shaderString.append(builder.fCompilerStrings[i]);
             shaderString.append("\n");
         }
     }
 
     shaderc_compiler_t compiler = gpu->shadercCompiler();
 
@@ skipping 39 matching lines @@
     stageInfo->pNext = nullptr;
     stageInfo->flags = 0;
     stageInfo->stage = stage;
     stageInfo->module = *shaderModule;
     stageInfo->pName = "main";
     stageInfo->pSpecializationInfo = nullptr;
 
     return true;
 }
 
-GrVkProgram* GrVkProgramBuilder::finalize(GrPrimitiveType primitiveType,
-                                          const GrVkRenderPass& renderPass) {
+GrVkPipelineState* GrVkPipelineStateBuilder::finalize(GrPrimitiveType primitiveType,
+                                                      const GrVkRenderPass& renderPass,
+                                                      const GrVkPipelineState::Desc& desc) {
     VkDescriptorSetLayout dsLayout[2];
     VkPipelineLayout pipelineLayout;
     VkShaderModule vertShaderModule;
     VkShaderModule fragShaderModule;
 
     uint32_t numSamplers = fSamplerUniforms.count();
 
     SkAutoTDeleteArray<VkDescriptorSetLayoutBinding> dsSamplerBindings(
                                                      new VkDescriptorSetLayoutBinding[numSamplers]);
     for (uint32_t i = 0; i < numSamplers; ++i) {
@@ skipping 110 matching lines @@
     if (!pipeline) {
         GR_VK_CALL(fGpu->vkInterface(), DestroyPipelineLayout(fGpu->device(), pipelineLayout,
                                                               nullptr));
         GR_VK_CALL(fGpu->vkInterface(), DestroyDescriptorSetLayout(fGpu->device(), dsLayout[0],
                                                                    nullptr));
         GR_VK_CALL(fGpu->vkInterface(), DestroyDescriptorSetLayout(fGpu->device(), dsLayout[1],
                                                                    nullptr));
         return nullptr;
     }
 
-    return new GrVkProgram(fGpu,
-                           pipeline,
-                           pipelineLayout,
-                           dsLayout,
-                           fUniformHandles,
-                           fUniformHandler.fUniforms,
-                           fUniformHandler.fCurrentVertexUBOOffset,
-                           fUniformHandler.fCurrentFragmentUBOOffset,
-                           numSamplers,
-                           fGeometryProcessor,
-                           fXferProcessor,
-                           fFragmentProcessors);
+    return new GrVkPipelineState(fGpu,
+                                 desc,
+                                 pipeline,
+                                 pipelineLayout,
+                                 dsLayout,
+                                 fUniformHandles,
+                                 fUniformHandler.fUniforms,
+                                 fUniformHandler.fCurrentVertexUBOOffset,
+                                 fUniformHandler.fCurrentFragmentUBOOffset,
+                                 numSamplers,
+                                 fGeometryProcessor,
+                                 fXferProcessor,
+                                 fFragmentProcessors);
 }