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

src/gpu/vk/GrVkRenderPass.cpp

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrVkRenderPass.h"
 
 #include "GrProcessor.h"
 #include "GrVkFramebuffer.h"
 #include "GrVkGpu.h"
 #include "GrVkRenderTarget.h"
 #include "GrVkUtil.h"
 
 typedef GrVkRenderPass::AttachmentsDescriptor::AttachmentDesc AttachmentDesc;
 
 void setup_vk_attachment_description(VkAttachmentDescription* attachment,
                                      const AttachmentDesc& desc,
                                      VkImageLayout layout) {
     attachment->flags = 0;
     attachment->format = desc.fFormat;
     SkAssertResult(GrSampleCountToVkSampleCount(desc.fSamples, &attachment->samples));
     switch (layout) {
         case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
-            attachment->loadOp = desc.fLoadOp;
-            attachment->storeOp = desc.fStoreOp;
+            attachment->loadOp = desc.fLoadStoreOps.fLoadOp;
+            attachment->storeOp = desc.fLoadStoreOps.fStoreOp;
             attachment->stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
             attachment->stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
             break;
         case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
             attachment->loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
             attachment->storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-            attachment->stencilLoadOp = desc.fLoadOp;
-            attachment->stencilStoreOp = desc.fStoreOp;
+            attachment->stencilLoadOp = desc.fLoadStoreOps.fLoadOp;
+            attachment->stencilStoreOp = desc.fLoadStoreOps.fStoreOp;
             break;
         default:
             SkFAIL("Unexpected attachment layout");
     }
 
     attachment->initialLayout = layout;
     attachment->finalLayout = layout;
 }
 
 void GrVkRenderPass::initSimple(const GrVkGpu* gpu, const GrVkRenderTarget& target) {
-    // Get attachment information from render target. This includes which attachments the render
-    // target has (color, resolve, stencil) and the attachments format and sample count.
-    target.getAttachmentsDescriptor(&fAttachmentsDescriptor, &fAttachmentFlags);
+    static const GrVkRenderPass::LoadStoreOps kBasicLoadStoreOps(VK_ATTACHMENT_LOAD_OP_LOAD,
+                                                                 VK_ATTACHMENT_STORE_OP_STORE);
 
+    this->init(gpu, target, kBasicLoadStoreOps, kBasicLoadStoreOps, kBasicLoadStoreOps);
+}
+
+void GrVkRenderPass::init(const GrVkGpu* gpu,
+                          const LoadStoreOps& colorOp,
+                          const LoadStoreOps& resolveOp,
+                          const LoadStoreOps& stencilOp) {
     uint32_t numAttachments = fAttachmentsDescriptor.fAttachmentCount;
     // Attachment descriptions to be set on the render pass
     SkTArray<VkAttachmentDescription> attachments(numAttachments);
     attachments.reset(numAttachments);
-    memset(attachments.begin(), 0, numAttachments*sizeof(VkAttachmentDescription));
+    memset(attachments.begin(), 0, numAttachments * sizeof(VkAttachmentDescription));
 
     // Refs to attachments on the render pass (as described by teh VkAttachmentDescription above),
     // that are used by the subpass.
     VkAttachmentReference colorRef;
     VkAttachmentReference resolveRef;
     VkAttachmentReference stencilRef;
     uint32_t currentAttachment = 0;
 
     // Go through each of the attachment types (color, resolve, stencil) and set the necessary
     // on the various Vk structs.
     VkSubpassDescription subpassDesc;
     memset(&subpassDesc, 0, sizeof(VkSubpassDescription));
     subpassDesc.flags = 0;
     subpassDesc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
     subpassDesc.inputAttachmentCount = 0;
     subpassDesc.pInputAttachments = nullptr;
     if (fAttachmentFlags & kColor_AttachmentFlag) {
         // set up color attachment
+        fAttachmentsDescriptor.fColor.fLoadStoreOps = colorOp;
         setup_vk_attachment_description(&attachments[currentAttachment],
                                         fAttachmentsDescriptor.fColor,
                                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
         // setup subpass use of attachment
         colorRef.attachment = currentAttachment++;
         colorRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
         subpassDesc.colorAttachmentCount = 1;
     } else {
         // I don't think there should ever be a time where we don't have a color attachment
         SkASSERT(false);
         colorRef.attachment = VK_ATTACHMENT_UNUSED;
         colorRef.layout = VK_IMAGE_LAYOUT_UNDEFINED;
         subpassDesc.colorAttachmentCount = 0;
     }
     subpassDesc.pColorAttachments = &colorRef;
 
     if (fAttachmentFlags & kResolve_AttachmentFlag) {
         // set up resolve attachment
+        fAttachmentsDescriptor.fResolve.fLoadStoreOps = resolveOp;
         setup_vk_attachment_description(&attachments[currentAttachment],
                                         fAttachmentsDescriptor.fResolve,
                                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
         // setup subpass use of attachment
         resolveRef.attachment = currentAttachment++;
         // I'm really not sure what the layout should be for the resolve textures.
         resolveRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
         subpassDesc.pResolveAttachments = &resolveRef;
     } else {
         subpassDesc.pResolveAttachments = nullptr;
     }
 
     if (fAttachmentFlags & kStencil_AttachmentFlag) {
         // set up stencil attachment
+        fAttachmentsDescriptor.fStencil.fLoadStoreOps = stencilOp;
         setup_vk_attachment_description(&attachments[currentAttachment],
                                         fAttachmentsDescriptor.fStencil,
                                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
         // setup subpass use of attachment
         stencilRef.attachment = currentAttachment++;
         stencilRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
     } else {
         stencilRef.attachment = VK_ATTACHMENT_UNUSED;
         stencilRef.layout = VK_IMAGE_LAYOUT_UNDEFINED;
     }
@@ skipping 16 matching lines @@
     createInfo.pSubpasses = &subpassDesc;
     createInfo.dependencyCount = 0;
     createInfo.pDependencies = nullptr;
 
     GR_VK_CALL_ERRCHECK(gpu->vkInterface(), CreateRenderPass(gpu->device(),
                                                              &createInfo,
                                                              nullptr,
                                                              &fRenderPass));
 }
 
+void GrVkRenderPass::init(const GrVkGpu* gpu,
+                          const GrVkRenderPass& compatibleRenderPass,
+                          const LoadStoreOps& colorOp,
+                          const LoadStoreOps& resolveOp,
+                          const LoadStoreOps& stencilOp) {
+    fAttachmentFlags = compatibleRenderPass.fAttachmentFlags;
+    fAttachmentsDescriptor = compatibleRenderPass.fAttachmentsDescriptor;
+    this->init(gpu, colorOp, resolveOp, stencilOp);
+}
+
+void GrVkRenderPass::init(const GrVkGpu* gpu,
+                          const GrVkRenderTarget& target, 
+                          const LoadStoreOps& colorOp,
+                          const LoadStoreOps& resolveOp,
+                          const LoadStoreOps& stencilOp) {
+    // Get attachment information from render target. This includes which attachments the render
+    // target has (color, resolve, stencil) and the attachments format and sample count.
+    target.getAttachmentsDescriptor(&fAttachmentsDescriptor, &fAttachmentFlags);
+    this->init(gpu, colorOp, resolveOp, stencilOp);
+}
+
 void GrVkRenderPass::freeGPUData(const GrVkGpu* gpu) const {
     GR_VK_CALL(gpu->vkInterface(), DestroyRenderPass(gpu->device(), fRenderPass, nullptr));
 }
 
 // Works under the assumption that color attachment will always be the first attachment in our
 // attachment array if it exists.
 bool GrVkRenderPass::colorAttachmentIndex(uint32_t* index) const {
     *index = 0;
     if (fAttachmentFlags & kColor_AttachmentFlag) {
         return true;
@@ skipping 73 matching lines @@
     }
     if (fAttachmentFlags & kStencil_AttachmentFlag) {
         if (!fAttachmentsDescriptor.fStencil.isCompatible(desc.fStencil)) {
             return false;
         }
     }
 
     return true;
 }
 
+bool GrVkRenderPass::equalLoadStoreOps(const LoadStoreOps& colorOps,
+                                       const LoadStoreOps& resolveOps,
+                                       const LoadStoreOps& stencilOps) const {
+    if (fAttachmentFlags & kColor_AttachmentFlag) {
+        if (fAttachmentsDescriptor.fColor.fLoadStoreOps != colorOps) {
+            return false;
+        }
+    }
+    if (fAttachmentFlags & kResolve_AttachmentFlag) {
+        if (fAttachmentsDescriptor.fResolve.fLoadStoreOps != resolveOps) {
+            return false;
+        }
+    }
+    if (fAttachmentFlags & kStencil_AttachmentFlag) {
+        if (fAttachmentsDescriptor.fStencil.fLoadStoreOps != stencilOps) {
+            return false;
+        }
+    }
+    return true;
+}
+
 void GrVkRenderPass::genKey(GrProcessorKeyBuilder* b) const {
     b->add32(fAttachmentFlags);
     if (fAttachmentFlags & kColor_AttachmentFlag) {
         b->add32(fAttachmentsDescriptor.fColor.fFormat);
         b->add32(fAttachmentsDescriptor.fColor.fSamples);
     }
     if (fAttachmentFlags & kResolve_AttachmentFlag) {
         b->add32(fAttachmentsDescriptor.fResolve.fFormat);
         b->add32(fAttachmentsDescriptor.fResolve.fSamples);
     }
     if (fAttachmentFlags & kStencil_AttachmentFlag) {
         b->add32(fAttachmentsDescriptor.fStencil.fFormat);
         b->add32(fAttachmentsDescriptor.fStencil.fSamples);
     }
 }