Refactor creation of GrVkRenderPasses to make them move general

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"
@@ skipping 10 matching lines @@
 
 GrVkResourceProvider::GrVkResourceProvider(GrVkGpu* gpu)
     : fGpu(gpu)
     , fPipelineCache(VK_NULL_HANDLE)
     , fUniformDescPool(nullptr)
     , fCurrentUniformDescCount(0) {
     fPipelineStateCache = new PipelineStateCache(gpu);
 }
 
 GrVkResourceProvider::~GrVkResourceProvider() {
-    SkASSERT(0 == fSimpleRenderPasses.count());
+    SkASSERT(0 == fRenderPassArray.count());
     SkASSERT(VK_NULL_HANDLE == fPipelineCache);
     delete fPipelineStateCache;
 }
 
 void GrVkResourceProvider::initUniformDescObjects() {
     // Create Uniform Buffer Descriptor
     // The vertex uniform buffer will have binding 0 and the fragment binding 1.
     VkDescriptorSetLayoutBinding dsUniBindings[2];
     memset(&dsUniBindings, 0, 2 * sizeof(VkDescriptorSetLayoutBinding));
     dsUniBindings[0].binding = GrVkUniformHandler::kVertexBinding;
@@ skipping 53 matching lines @@
 
     return GrVkPipeline::Create(fGpu, pipeline, primProc, shaderStageInfo, shaderStageCount,
                                 primitiveType, renderPass, layout, fPipelineCache);
 }
 
 
 // To create framebuffers, we first need to create a simple RenderPass that is
 // only used for framebuffer creation. When we actually render we will create
 // RenderPasses as needed that are compatible with the framebuffer.
 const GrVkRenderPass*
-GrVkResourceProvider::findOrCreateCompatibleRenderPass(const GrVkRenderTarget& target) {
-    for (int i = 0; i < fSimpleRenderPasses.count(); ++i) {
-        GrVkRenderPass* renderPass = fSimpleRenderPasses[i];
-        if (renderPass->isCompatible(target)) {
+GrVkResourceProvider::findCompatibleRenderPass(const GrVkRenderTarget& target,
+                                               CompatibleRPHandle* compatibleHandle) {
+    for (int i = 0; i < fRenderPassArray.count(); ++i) {
+        if (fRenderPassArray[i].isCompatible(target)) {
+            const GrVkRenderPass* renderPass = fRenderPassArray[i].getCompatibleRenderPass();
             renderPass->ref();
+            if (compatibleHandle) {
+                *compatibleHandle = CompatibleRPHandle(i);
+            }
             return renderPass;
         }
     }
 
-    GrVkRenderPass* renderPass = new GrVkRenderPass();
-    renderPass->initSimple(fGpu, target);
-    fSimpleRenderPasses.push_back(renderPass);
+    const GrVkRenderPass* renderPass =
+        fRenderPassArray.emplace_back(fGpu, target).getCompatibleRenderPass();
+    renderPass->ref();
+
+    if (compatibleHandle) {
+        *compatibleHandle = CompatibleRPHandle(fRenderPassArray.count() - 1);
+    }
+    return renderPass;
+}
+
+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;
 }
 
 GrVkDescriptorPool* GrVkResourceProvider::findOrCreateCompatibleDescriptorPool(
                                                             VkDescriptorType type, uint32_t count) {
     return new GrVkDescriptorPool(fGpu, type, count);
 }
 
 GrVkSampler* GrVkResourceProvider::findOrCreateCompatibleSampler(const GrTextureParams& params,
@@ skipping 64 matching lines @@
 
 void GrVkResourceProvider::destroyResources() {
     // release our current command buffers
     for (int i = 0; i < fActiveCommandBuffers.count(); ++i) {
         SkASSERT(fActiveCommandBuffers[i]->finished(fGpu));
         SkASSERT(fActiveCommandBuffers[i]->unique());
         fActiveCommandBuffers[i]->unref(fGpu);
     }
     fActiveCommandBuffers.reset();
 
-    // loop over all render passes to make sure we destroy all the internal VkRenderPasses
-    for (int i = 0; i < fSimpleRenderPasses.count(); ++i) {
-        fSimpleRenderPasses[i]->unref(fGpu);
+    // loop over all render pass sets to make sure we destroy all the internal VkRenderPasses
+    for (int i = 0; i < fRenderPassArray.count(); ++i) {
+        fRenderPassArray[i].releaseResources(fGpu);
     }
-    fSimpleRenderPasses.reset();
+    fRenderPassArray.reset();
 
     // Iterate through all store GrVkSamplers and unref them before resetting the hash.
     SkTDynamicHash<GrVkSampler, uint16_t>::Iter iter(&fSamplers);
     for (; !iter.done(); ++iter) {
         (*iter).unref(fGpu);
     }
     fSamplers.reset();
 
     fPipelineStateCache->release();
 
@@ skipping 14 matching lines @@
 }
 
 void GrVkResourceProvider::abandonResources() {
     // release our current command buffers
     for (int i = 0; i < fActiveCommandBuffers.count(); ++i) {
         SkASSERT(fActiveCommandBuffers[i]->finished(fGpu));
         fActiveCommandBuffers[i]->unrefAndAbandon();
     }
     fActiveCommandBuffers.reset();
 
-    for (int i = 0; i < fSimpleRenderPasses.count(); ++i) {
-        fSimpleRenderPasses[i]->unrefAndAbandon();
+    // loop over all render pass sets to make sure we destroy all the internal VkRenderPasses
+    for (int i = 0; i < fRenderPassArray.count(); ++i) {
+        fRenderPassArray[i].abandonResources();
     }
-    fSimpleRenderPasses.reset();
+    fRenderPassArray.reset();
 
     // Iterate through all store GrVkSamplers and unrefAndAbandon them before resetting the hash.
     SkTDynamicHash<GrVkSampler, uint16_t>::Iter iter(&fSamplers);
     for (; !iter.done(); ++iter) {
         (*iter).unrefAndAbandon();
     }
     fSamplers.reset();
 
     fPipelineStateCache->abandon();
 
 #ifdef SK_TRACE_VK_RESOURCES
     SkASSERT(0 == GrVkResource::fTrace.count());
 #endif
     fPipelineCache = VK_NULL_HANDLE;
 
     fUniformDescLayout = VK_NULL_HANDLE;
     fUniformDescPool->unrefAndAbandon();
 }
+
+////////////////////////////////////////////////////////////////////////////////
+
+GrVkResourceProvider::CompatibleRenderPassSet::CompatibleRenderPassSet(
+                                                                     const GrVkGpu* gpu,
+                                                                     const GrVkRenderTarget& target)
+    : fLastReturnedIndex(0) {
+    fRenderPasses.emplace_back(new GrVkRenderPass());
+    fRenderPasses[0]->initSimple(gpu, target);

[jvanverth1, 2016/06/02 20:09:35]

So at the moment each set only has one renderpass, correct? But eventually we'll
have other ones that differ only in their LoadStore params.

[egdaniel, 2016/06/02 20:50:26]

Yes currently it will always be the load and store RP. The general flow of
things will be when starting a new GpuCommandBuffer in GrDrawTarget we send down
the RenderTarget and LoadStoreOps to the creation of the GrVkGpuCommandBuffer.
Here it will ask the ResourceProvider to find a RP which is compatible to the RT
and has the requested LoadStoreOps. This find function is implemented in the
follow on patch I've put up. But basically it will append a new RP to this array
if one with that LoadStoreOp hasn't been created yet.

+}
+
+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);
+}
+
+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;
+        }
+    }
+}