Use dynamic state from vulkan pipelines

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 "GrVkPipeline.h"
 #include "GrVkResource.h"
 #include "GrVkUtil.h"
 #include "vulkan/vulkan.h"
 
+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 State/Object bindings
-    ////////////////////////////////////////////////////////////////////////////
-#if 0
-    void bindPipeline(const GrVkGpu* gpu) const;
-    void bindDynamicState(const GrVkGpu* gpu) const;
-    void bindDescriptorSet(const GrVkGpu* gpu) const;
-#endif
-
-    ////////////////////////////////////////////////////////////////////////////
     // CommandBuffer commands
     ////////////////////////////////////////////////////////////////////////////
     enum BarrierType {
         kMemory_BarrierType,
         kBufferMemory_BarrierType,
         kImageMemory_BarrierType
     };
 
     void pipelineBarrier(const GrVkGpu* gpu,
                          VkPipelineStageFlags srcStageMask,
@@ skipping 23 matching lines @@
             GR_VK_CALL(gpu->vkInterface(), CmdBindIndexBuffer(fCmdBuffer,
                                                               vkBuffer,
                                                               0,
                                                               VK_INDEX_TYPE_UINT16));
             fBoundIndexBufferIsValid = true;
             fBoundIndexBuffer = vkBuffer;
             addResource(ibuffer->resource());
         }
     }
 
-    void bindPipeline(const GrVkGpu* gpu, const GrVkPipeline* pipeline) {
-        GR_VK_CALL(gpu->vkInterface(), CmdBindPipeline(fCmdBuffer,
-                                                       VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                                       pipeline->pipeline()));
-        addResource(pipeline);
-    }
-
     void bindDescriptorSets(const GrVkGpu* gpu,
                             GrVkProgram*,
                             VkPipelineLayout layout,
                             uint32_t firstSet,
                             uint32_t setCount,
                             const VkDescriptorSet* descriptorSets,
                             uint32_t dynamicOffsetCount,
                             const uint32_t* dynamicOffsets);
 
+    void setViewport(const GrVkGpu* gpu,
+                     uint32_t firstViewport,
+                     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 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 22 matching lines @@
                            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 bindPipeline(const GrVkGpu* gpu, const GrVkPipeline* pipeline);
+
+
     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,
@@ skipping 36 matching lines @@
     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];
 };
 
 
 #endif