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

src/gpu/vk/GrVkResourceProvider.h

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #ifndef GrVkResourceProvider_DEFINED
 #define GrVkResourceProvider_DEFINED
 
 #include "GrGpu.h"
 #include "GrResourceHandle.h"
 #include "GrVkDescriptorPool.h"
 #include "GrVkPipelineState.h"
+#include "GrVkRenderPass.h"
 #include "GrVkResource.h"
 #include "GrVkUtil.h"
 #include "SkTArray.h"
 #include "SkTDynamicHash.h"
 #include "SkTHash.h"
 #include "SkTInternalLList.h"
 
 #include "vk/GrVkDefines.h"
 
 class GrPipeline;
 class GrPrimitiveProcessor;
 class GrTextureParams;
 class GrVkCommandBuffer;
 class GrVkGpu;
 class GrVkPipeline;
-class GrVkRenderPass;
 class GrVkRenderTarget;
 class GrVkSampler;
 
 class GrVkResourceProvider {
 public:
     GrVkResourceProvider(GrVkGpu* gpu);
     ~GrVkResourceProvider();
 
     // Set up any initial vk objects
     void init();
@@ skipping 11 matching lines @@
     // Finds or creates a simple render pass that matches the target, increments the refcount,
     // and returns. The caller can optionally pass in a pointer to a CompatibleRPHandle. If this is
     // non null it will be set to a handle that can be used in the furutre to quickly return a
     // compatible GrVkRenderPasses without the need inspecting a GrVkRenderTarget.
     const GrVkRenderPass* findCompatibleRenderPass(const GrVkRenderTarget& target,
                                                    CompatibleRPHandle* compatibleHandle = nullptr);
     // The CompatibleRPHandle must be a valid handle previously set by a call to
     // findCompatibleRenderPass(GrVkRenderTarget&, CompatibleRPHandle*).
     const GrVkRenderPass* findCompatibleRenderPass(const CompatibleRPHandle& compatibleHandle);
 
-#if 0
-    // TODO:
+    // Finds or creates a render pass that matches the target and LoadStoreOps, increments the
+    // refcount, and returns. The caller can optionally pass in a pointer to a CompatibleRPHandle.
+    // If this is non null it will be set to a handle that can be used in the furutre to quickly
+    // return a GrVkRenderPasses without the need inspecting a GrVkRenderTarget.
     const GrVkRenderPass* findRenderPass(const GrVkRenderTarget& target,
-                                         VkAttachmentLoadOp colorLoad,
-                                         VkAttachmentStoreOp colorStore,
-                                         VkAttachmentLoadOp stencilLoad,
-                                         VkAttachmentStoreOp stencilStore,
+                                         const GrVkRenderPass::LoadStoreOps& colorOps,
+                                         const GrVkRenderPass::LoadStoreOps& resolveOps,
+                                         const GrVkRenderPass::LoadStoreOps& stencilOps,
                                          CompatibleRPHandle* compatibleHandle = nullptr);
 
+    // The CompatibleRPHandle must be a valid handle previously set by a call to findRenderPass or
+    // findCompatibleRenderPass.
     const GrVkRenderPass* findRenderPass(const CompatibleRPHandle& compatibleHandle,
-                                         VkAttachmentLoadOp colorLoad,
-                                         VkAttachmentStoreOp colorStore,
-                                         VkAttachmentLoadOp stencilLoad,
-                                         VkAttachmentStoreOp stencilStore);
-#endif
+                                         const GrVkRenderPass::LoadStoreOps& colorOps,
+                                         const GrVkRenderPass::LoadStoreOps& resolveOps,
+                                         const GrVkRenderPass::LoadStoreOps& stencilOps);
+
 
     GrVkCommandBuffer* createCommandBuffer();
     void checkCommandBuffers();
 
     // Finds or creates a compatible GrVkDescriptorPool for the requested type and count.
     // The refcount is incremented and a pointer returned.
     // TODO: Currently this will just create a descriptor pool without holding onto a ref itself
     //       so we currently do not reuse them. Rquires knowing if another draw is currently using
     //       the GrVkDescriptorPool, the ability to reset pools, and the ability to purge pools out
     //       of our cache of GrVkDescriptorPools.
@@ skipping 81 matching lines @@
 
         bool isCompatible(const GrVkRenderTarget& target) const;
 
         GrVkRenderPass* getCompatibleRenderPass() const {
             // The first GrVkRenderpass should always exists since we create the basic load store
             // render pass on create
             SkASSERT(fRenderPasses[0]);
             return fRenderPasses[0];
         }
 
+        GrVkRenderPass* getRenderPass(const GrVkGpu* gpu,
+                                      const GrVkRenderPass::LoadStoreOps& colorOps,
+                                      const GrVkRenderPass::LoadStoreOps& resolveOps,
+                                      const GrVkRenderPass::LoadStoreOps& stencilOps);
+
         void releaseResources(const GrVkGpu* gpu);
         void abandonResources();
 
     private:
         SkSTArray<4, GrVkRenderPass*> fRenderPasses;
         int                           fLastReturnedIndex;
     };
 
     // Initialiaze the vkDescriptorSetLayout used for allocating new uniform buffer descritpor sets.
     void initUniformDescObjects();
@@ skipping 23 matching lines @@
     int                fCurrMaxUniDescriptors;
 
     enum {
         kMaxUniformDescriptors = 1024,
         kNumUniformDescPerSet = 2,
         kStartNumUniformDescriptors = 16, // must be less than kMaxUniformDescriptors
     };
 };
 
 #endif