Add discard support to Vulkan

src/gpu/vk/GrVkGpuCommandBuffer.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 "GrVkGpuCommandBuffer.h"
 
 #include "GrMesh.h"
@@ skipping 112 matching lines @@
                                           VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                                           VK_ACCESS_SHADER_READ_BIT,
                                           VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
                                           false);
     }
 
     fGpu->submitSecondaryCommandBuffer(fCommandBuffer, fRenderPass, &fColorClearValue,
                                        fRenderTarget, bounds);
 }
 
+void GrVkGpuCommandBuffer::discard(GrRenderTarget* target) {
+    if (fIsEmpty) {
+        // We will change the render pass to do a clear load instead
+        GrVkRenderPass::LoadStoreOps vkColorOps(VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                                VK_ATTACHMENT_STORE_OP_STORE);
+        GrVkRenderPass::LoadStoreOps vkStencilOps(VK_ATTACHMENT_LOAD_OP_LOAD,

[jvanverth1, 2016/06/29 16:00:30]

Shouldn't this and the resolve be LOAD_OP_DONT_CARE as well?

[egdaniel, 2016/06/29 16:11:30]

In general, when we call discard on a RT do we mean it for both color and
stencil?

In a follow on CL I'm actually going to experiment with making stencil DONT_CARE
always for both load and store (there are some unlucky situations where this
could cause a bug, but we'll see how bad it is/isn't).

For resolve it doesn't matter right now what we put here since it is not used.

[bsalomon, 2016/06/29 17:45:24]

both, I guess? The current discard stuff is not useful in the GL backend so
redefine it as you see fit.

+                                                  VK_ATTACHMENT_STORE_OP_STORE);
+        GrVkRenderPass::LoadStoreOps vkResolveOps(VK_ATTACHMENT_LOAD_OP_LOAD,
+                                                  VK_ATTACHMENT_STORE_OP_STORE);
+
+        const GrVkRenderPass* oldRP = fRenderPass;
+
+        GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(target);
+        const GrVkResourceProvider::CompatibleRPHandle& rpHandle =
+            vkRT->compatibleRenderPassHandle();
+        if (rpHandle.isValid()) {
+            fRenderPass = fGpu->resourceProvider().findRenderPass(rpHandle,
+                                                                  vkColorOps,
+                                                                  vkResolveOps,
+                                                                  vkStencilOps);
+        } else {
+            fRenderPass = fGpu->resourceProvider().findRenderPass(*vkRT,
+                                                                  vkColorOps,
+                                                                  vkResolveOps,
+                                                                  vkStencilOps);
+        }
+
+        SkASSERT(fRenderPass->isCompatible(*oldRP));
+        oldRP->unref(fGpu);
+    }
+}
+
 void GrVkGpuCommandBuffer::onClearStencilClip(GrRenderTarget* target,
                                               const SkIRect& rect,
                                               bool insideClip) {
     SkASSERT(target);
 
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(target);
     GrStencilAttachment* sb = target->renderTargetPriv().getStencilAttachment();
     // this should only be called internally when we know we have a
     // stencil buffer.
     SkASSERT(sb);
@@ skipping 245 matching lines @@
             fGpu->stats()->incNumDraws();
         } while ((nonIdxMesh = iter.next()));
     }
 
     // Technically we don't have to call this here (since there is a safety check in
     // pipelineState:setData but this will allow for quicker freeing of resources if the
     // pipelineState sits in a cache for a while.
     pipelineState->freeTempResources(fGpu);
 }