Add support for finding/creating general GrVkRenderPass from the VkResourceProvider.

src/gpu/vk/GrVkResourceProvider.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 "GrVkResourceProvider.h"
 
 #include "GrTextureParams.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkPipeline.h"
-#include "GrVkRenderPass.h"
 #include "GrVkSampler.h"
 #include "GrVkUtil.h"
 
 #ifdef SK_TRACE_VK_RESOURCES
 SkTDynamicHash<GrVkResource, uint32_t> GrVkResource::fTrace;
 SkRandom GrVkResource::fRandom;
 #endif
 
 GrVkResourceProvider::GrVkResourceProvider(GrVkGpu* gpu)
     : fGpu(gpu)
@@ skipping 103 matching lines @@
 
 const GrVkRenderPass*
 GrVkResourceProvider::findCompatibleRenderPass(const CompatibleRPHandle& compatibleHandle) {
     SkASSERT(compatibleHandle.isValid() && compatibleHandle.toIndex() < fRenderPassArray.count());
     int index = compatibleHandle.toIndex();
     const GrVkRenderPass* renderPass = fRenderPassArray[index].getCompatibleRenderPass();
     renderPass->ref();
     return renderPass;
 }
 
+const GrVkRenderPass* GrVkResourceProvider::findRenderPass(
+                                                     const GrVkRenderTarget& target,
+                                                     const GrVkRenderPass::LoadStoreOps& colorOps,
+                                                     const GrVkRenderPass::LoadStoreOps& resolveOps,
+                                                     const GrVkRenderPass::LoadStoreOps& stencilOps,
+                                                     CompatibleRPHandle* compatibleHandle) {
+    // This will get us the handle to (and possible create) the compatible set for the specific
+    // GrVkRenderPass we are looking for.
+    this->findCompatibleRenderPass(target, compatibleHandle);
+    return this->findRenderPass(*compatibleHandle, colorOps, resolveOps, stencilOps);
+}
+
+const GrVkRenderPass*
+GrVkResourceProvider::findRenderPass(const CompatibleRPHandle& compatibleHandle,
+                                     const GrVkRenderPass::LoadStoreOps& colorOps,
+                                     const GrVkRenderPass::LoadStoreOps& resolveOps,
+                                     const GrVkRenderPass::LoadStoreOps& stencilOps) {
+    SkASSERT(compatibleHandle.isValid() && compatibleHandle.toIndex() < fRenderPassArray.count());
+    CompatibleRenderPassSet& compatibleSet = fRenderPassArray[compatibleHandle.toIndex()];
+    const GrVkRenderPass* renderPass = compatibleSet.getRenderPass(fGpu,
+                                                                   colorOps,
+                                                                   resolveOps,
+                                                                   stencilOps);
+    renderPass->ref();
+    return renderPass;
+}
+
 GrVkDescriptorPool* GrVkResourceProvider::findOrCreateCompatibleDescriptorPool(
                                                             VkDescriptorType type, uint32_t count) {
     return new GrVkDescriptorPool(fGpu, type, count);
 }
 
 GrVkSampler* GrVkResourceProvider::findOrCreateCompatibleSampler(const GrTextureParams& params,
                                                                  uint32_t mipLevels) {
     GrVkSampler* sampler = fSamplers.find(GrVkSampler::GenerateKey(params, mipLevels));
     if (!sampler) {
         sampler = GrVkSampler::Create(fGpu, params, mipLevels);
@@ skipping 141 matching lines @@
 }
 
 bool GrVkResourceProvider::CompatibleRenderPassSet::isCompatible(
                                                              const GrVkRenderTarget& target) const {
     // The first GrVkRenderpass should always exists since we create the basic load store
     // render pass on create
     SkASSERT(fRenderPasses[0]);
     return fRenderPasses[0]->isCompatible(target);
 }
 
+GrVkRenderPass* GrVkResourceProvider::CompatibleRenderPassSet::getRenderPass(
+                                                   const GrVkGpu* gpu,
+                                                   const GrVkRenderPass::LoadStoreOps& colorOps,
+                                                   const GrVkRenderPass::LoadStoreOps& resolveOps,
+                                                   const GrVkRenderPass::LoadStoreOps& stencilOps) {
+    for (int i = 0; i < fRenderPasses.count(); ++i) {
+        int idx = (i + fLastReturnedIndex) % fRenderPasses.count();
+        if (fRenderPasses[idx]->equalLoadStoreOps(colorOps, resolveOps, stencilOps)) {
+            fLastReturnedIndex = idx;
+            return fRenderPasses[idx];
+        }
+    }
+    GrVkRenderPass* renderPass = fRenderPasses.push_back();
+    renderPass->init(gpu, *this->getCompatibleRenderPass(), colorOps, resolveOps, stencilOps);
+    fLastReturnedIndex = fRenderPasses.count() - 1;
+    return renderPass;
+}
+
 void GrVkResourceProvider::CompatibleRenderPassSet::releaseResources(const GrVkGpu* gpu) {
     for (int i = 0; i < fRenderPasses.count(); ++i) {
         if (fRenderPasses[i]) {
             fRenderPasses[i]->unref(gpu);
             fRenderPasses[i] = nullptr;
         }
     }
 }
 
 void GrVkResourceProvider::CompatibleRenderPassSet::abandonResources() {
     for (int i = 0; i < fRenderPasses.count(); ++i) {
         if (fRenderPasses[i]) {
             fRenderPasses[i]->unrefAndAbandon();
             fRenderPasses[i] = nullptr;
         }
     }
 }