Add GrVkCopyPipeline to handle vulkan copies as draws

src/gpu/vk/GrVkCommandBuffer.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 "GrVkCommandBuffer.h"
 
 #include "GrVkFramebuffer.h"
@@ skipping 172 matching lines @@
                                                          VK_PIPELINE_BIND_POINT_GRAPHICS,
                                                          layout,
                                                          firstSet,
                                                          setCount,
                                                          descriptorSets,
                                                          dynamicOffsetCount,
                                                          dynamicOffsets));
     pipelineState->addUniformResources(*this);
 }
 
+void GrVkCommandBuffer::bindDescriptorSets(const GrVkGpu* gpu,

[jvanverth1, 2016/09/26 17:26:11]

Just making sure -- is there any way the descriptorSets can be modified before
this command completes on the GPU? (There's a warning about that in the spec.)

[egdaniel, 2016/09/26 21:12:39]

Just in the same way the descriptor sets we bind in the above function call can
be changed. We rely on the resource provider to give us a free descriptor set to
use.

+                                           const SkTArray<const GrVkRecycledResource*>& recycled,
+                                           const SkTArray<const GrVkResource*>& resources,
+                                           VkPipelineLayout layout,
+                                           uint32_t firstSet,
+                                           uint32_t setCount,
+                                           const VkDescriptorSet* descriptorSets,
+                                           uint32_t dynamicOffsetCount,
+                                           const uint32_t* dynamicOffsets) {
+    SkASSERT(fIsActive);
+    GR_VK_CALL(gpu->vkInterface(), CmdBindDescriptorSets(fCmdBuffer,
+                                                         VK_PIPELINE_BIND_POINT_GRAPHICS,
+                                                         layout,
+                                                         firstSet,
+                                                         setCount,
+                                                         descriptorSets,
+                                                         dynamicOffsetCount,
+                                                         dynamicOffsets));
+    for (int i = 0; i < recycled.count(); ++i) {
+        this->addRecycledResource(recycled[i]);
+    }
+    for (int i = 0; i < resources.count(); ++i) {
+        this->addResource(resources[i]);
+    }
+}
+
 void GrVkCommandBuffer::bindPipeline(const GrVkGpu* gpu, const GrVkPipeline* pipeline) {
     SkASSERT(fIsActive);
     GR_VK_CALL(gpu->vkInterface(), CmdBindPipeline(fCmdBuffer,
                                                    VK_PIPELINE_BIND_POINT_GRAPHICS,
                                                    pipeline->pipeline()));
     this->addResource(pipeline);
 }
 
 void GrVkCommandBuffer::drawIndexed(const GrVkGpu* gpu,
                                     uint32_t indexCount,
@@ skipping 457 matching lines @@
     fIsActive = true;
 }
 
 void GrVkSecondaryCommandBuffer::end(const GrVkGpu* gpu) {
     SkASSERT(fIsActive);
     GR_VK_CALL_ERRCHECK(gpu->vkInterface(), EndCommandBuffer(fCmdBuffer));
     this->invalidateState();
     fIsActive = false;
 }