Subclass GrVkCommandBuffer into Primary and Secondary CommandBuffers.

src/gpu/vk/GrVkCommandBuffer.h

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #ifndef GrVkCommandBuffer_DEFINED
 #define GrVkCommandBuffer_DEFINED
 
 #include "GrVkGpu.h"
 #include "GrVkResource.h"
 #include "GrVkUtil.h"
 #include "vk/GrVkDefines.h"
 
+class GrVkFramebuffer;
 class GrVkPipeline;
 class GrVkRenderPass;
 class GrVkRenderTarget;
 class GrVkTransferBuffer;
 
 class GrVkCommandBuffer : public GrVkResource {
 public:
-    static GrVkCommandBuffer* Create(const GrVkGpu* gpu, VkCommandPool cmdPool);
     ~GrVkCommandBuffer() override;
 
-    void begin(const GrVkGpu* gpu);
-    void end(const GrVkGpu* gpu);
-
     void invalidateState();
 
-    // Begins render pass on this command buffer. The framebuffer from GrVkRenderTarget will be used
-    // in the render pass.
-    void beginRenderPass(const GrVkGpu* gpu,
-                         const GrVkRenderPass* renderPass,
-                         const GrVkRenderTarget& target);
-    void endRenderPass(const GrVkGpu* gpu);
-
-    void submitToQueue(const GrVkGpu* gpu, VkQueue queue, GrVkGpu::SyncQueue sync);
-    bool finished(const GrVkGpu* gpu) const;
-
     ////////////////////////////////////////////////////////////////////////////
     // CommandBuffer commands
     ////////////////////////////////////////////////////////////////////////////
     enum BarrierType {
         kMemory_BarrierType,
         kBufferMemory_BarrierType,
         kImageMemory_BarrierType
     };
 
     void pipelineBarrier(const GrVkGpu* gpu,
@@ skipping 47 matching lines @@
                      uint32_t viewportCount,
                      const VkViewport* viewports);
 
     void setScissor(const GrVkGpu* gpu,
                     uint32_t firstScissor,
                     uint32_t scissorCount,
                     const VkRect2D* scissors);
 
     void setBlendConstants(const GrVkGpu* gpu, const float blendConstants[4]);
 
+    // Commands that only work inside of a render pass
+    void clearAttachments(const GrVkGpu* gpu,
+                          int numAttachments,
+                          const VkClearAttachment* attachments,
+                          int numRects,
+                          const VkClearRect* clearRects) const;
+
+    void drawIndexed(const GrVkGpu* gpu,
+                     uint32_t indexCount,
+                     uint32_t instanceCount,
+                     uint32_t firstIndex,
+                     int32_t vertexOffset,
+                     uint32_t firstInstance) const;
+
+    void draw(const GrVkGpu* gpu,
+              uint32_t vertexCount,
+              uint32_t instanceCount,
+              uint32_t firstVertex,
+              uint32_t firstInstance) const;
+
+    // Add ref-counted resource that will be tracked and released when this
+    // command buffer finishes execution
+    void addResource(const GrVkResource* resource) {
+        resource->ref();
+        fTrackedResources.push_back(resource);
+    }
+
+protected:
+        GrVkCommandBuffer(VkCommandBuffer cmdBuffer, const GrVkRenderPass* rp = VK_NULL_HANDLE)
+            : fTrackedResources(kInitialTrackedResourcesCount)
+            , fIsActive(false)
+            , fActiveRenderPass(rp)
+            , fCmdBuffer(cmdBuffer)
+            , fSubmitFence(VK_NULL_HANDLE)
+            , fBoundVertexBufferIsValid(false)
+            , fBoundIndexBufferIsValid(false) {
+            this->invalidateState();
+        }
+        SkTArray<const GrVkResource*, true>     fTrackedResources;
+
+        // Tracks whether we are in the middle of a command buffer begin/end calls and thus can add
+        // new commands to the buffer;
+        bool fIsActive;
+
+        // Stores a pointer to the current active render pass (i.e. begin has been called but not
+        // end). A nullptr means there is no active render pass. The GrVKCommandBuffer does not own
+        // the render pass.
+        const GrVkRenderPass*     fActiveRenderPass;
+
+        VkCommandBuffer                         fCmdBuffer;
+        VkFence                                 fSubmitFence;
+
+private:
+    static const int kInitialTrackedResourcesCount = 32;
+
+    void freeGPUData(const GrVkGpu* gpu) const override;
+    void abandonSubResources() const override;
+
+    VkBuffer                                fBoundVertexBuffer;
+    bool                                    fBoundVertexBufferIsValid;
+
+    VkBuffer                                fBoundIndexBuffer;
+    bool                                    fBoundIndexBufferIsValid;
+
+    // Cached values used for dynamic state updates
+    VkViewport fCachedViewport;
+    VkRect2D   fCachedScissor;
+    float      fCachedBlendConstant[4];
+};
+
+class GrVkSecondaryCommandBuffer;
+
+class GrVkPrimaryCommandBuffer : public GrVkCommandBuffer {
+public:
+    static GrVkPrimaryCommandBuffer* Create(const GrVkGpu* gpu, VkCommandPool cmdPool);
+
+    void begin(const GrVkGpu* gpu);
+    void end(const GrVkGpu* gpu);
+
+    // Begins render pass on this command buffer. The framebuffer from GrVkRenderTarget will be used
+    // in the render pass.
+    void beginRenderPass(const GrVkGpu* gpu,
+                         const GrVkRenderPass* renderPass,
+                         const GrVkRenderTarget& target);
+    void endRenderPass(const GrVkGpu* gpu);
+
+    void executeCommands(const GrVkGpu* gpu,

[jvanverth1, 2016/06/01 14:10:46]

Where is this defined? Also, maybe appendCommands? (I'm assuming this inserts
the secondary command buffer into the primary).

[egdaniel, 2016/06/01 17:50:49]

Sorry the definition happen to be sitting in another branch, moved it here now.
I like executeCommands here since that is the vulkan call we're making here.

+                         const GrVkSecondaryCommandBuffer* secondaryBuffer);
+
     // Commands that only work outside of a render pass
     void clearColorImage(const GrVkGpu* gpu,
                          GrVkImage* image,
                          const VkClearColorValue* color,
                          uint32_t subRangeCount,
                          const VkImageSubresourceRange* subRanges);
 
     void clearDepthStencilImage(const GrVkGpu* gpu,
                                 GrVkImage* image,
                                 const VkClearDepthStencilValue* color,
@@ skipping 44 matching lines @@
                            uint32_t copyRegionCount,
                            const VkBufferImageCopy* copyRegions);
 
     void copyBufferToImage(const GrVkGpu* gpu,
                            GrVkTransferBuffer* srcBuffer,
                            GrVkImage* dstImage,
                            VkImageLayout dstLayout,
                            uint32_t copyRegionCount,
                            const VkBufferImageCopy* copyRegions);
 
-    // Commands that only work inside of a render pass
-    void clearAttachments(const GrVkGpu* gpu,
-                          int numAttachments,
-                          const VkClearAttachment* attachments,
-                          int numRects,
-                          const VkClearRect* clearRects) const;
+    void submitToQueue(const GrVkGpu* gpu, VkQueue queue, GrVkGpu::SyncQueue sync);
+    bool finished(const GrVkGpu* gpu) const;
 
-    void drawIndexed(const GrVkGpu* gpu,
-                     uint32_t indexCount,
-                     uint32_t instanceCount,
-                     uint32_t firstIndex,
-                     int32_t vertexOffset,
-                     uint32_t firstInstance) const;
+private:
+    explicit GrVkPrimaryCommandBuffer(VkCommandBuffer cmdBuffer) : INHERITED(cmdBuffer) {}
 
-    void draw(const GrVkGpu* gpu,
-              uint32_t vertexCount,
-              uint32_t instanceCount,
-              uint32_t firstVertex,
-              uint32_t firstInstance) const;
+    typedef GrVkCommandBuffer INHERITED;
+};
 
-    // Add ref-counted resource that will be tracked and released when this
-    // command buffer finishes execution
-    void addResource(const GrVkResource* resource) {
-        resource->ref();
-        fTrackedResources.push_back(resource);
+class GrVkSecondaryCommandBuffer : public GrVkCommandBuffer {
+public:
+    static GrVkSecondaryCommandBuffer* Create(const GrVkGpu* gpu, VkCommandPool cmdPool, 
+                                              const GrVkRenderPass* compatibleRenderPass);
+
+    void begin(const GrVkGpu* gpu, const GrVkFramebuffer* framebuffer);
+    void end(const GrVkGpu* gpu);
+
+private:
+    explicit GrVkSecondaryCommandBuffer(VkCommandBuffer cmdBuffer,
+                                        const GrVkRenderPass* compatibleRenderPass)
+        : INHERITED(cmdBuffer, compatibleRenderPass) {
     }
 
-private:
-    static const int kInitialTrackedResourcesCount = 32;
-
-    explicit GrVkCommandBuffer(VkCommandBuffer cmdBuffer)
-        : fTrackedResources(kInitialTrackedResourcesCount)
-        , fCmdBuffer(cmdBuffer)
-        , fSubmitFence(VK_NULL_HANDLE)
-        , fBoundVertexBufferIsValid(false)
-        , fBoundIndexBufferIsValid(false)
-        , fIsActive(false)
-        , fActiveRenderPass(nullptr) {
-        this->invalidateState();
-    }
-
-    void freeGPUData(const GrVkGpu* gpu) const override;
-    void abandonSubResources() const override;
-
-    SkTArray<const GrVkResource*, true>     fTrackedResources;
-
-    VkCommandBuffer                         fCmdBuffer;
-    VkFence                                 fSubmitFence;
-
-    VkBuffer                                fBoundVertexBuffer;
-    bool                                    fBoundVertexBufferIsValid;
-
-    VkBuffer                                fBoundIndexBuffer;
-    bool                                    fBoundIndexBufferIsValid;
-
-    // Tracks whether we are in the middle of a command buffer begin/end calls and thus can add new
-    // commands to the buffer;
-    bool fIsActive;
-
-    // Stores a pointer to the current active render pass (i.e. begin has been called but not end).
-    // A nullptr means there is no active render pass. The GrVKCommandBuffer does not own the render
-    // pass.
-    const GrVkRenderPass*     fActiveRenderPass;
-
-    // Cached values used for dynamic state updates
-    VkViewport fCachedViewport;
-    VkRect2D   fCachedScissor;
-    float      fCachedBlendConstant[4];
+    typedef GrVkCommandBuffer INHERITED;
 };
 
-
 #endif