Use dynamic state from vulkan pipelines

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"
 #include "GrVkImageView.h"
+#include "GrVkPipeline.h"
 #include "GrVkRenderPass.h"
 #include "GrVkRenderTarget.h"
 #include "GrVkProgram.h"
 #include "GrVkTransferBuffer.h"
 #include "GrVkUtil.h"
 
 GrVkCommandBuffer* GrVkCommandBuffer::Create(const GrVkGpu* gpu, VkCommandPool cmdPool) {
     const VkCommandBufferAllocateInfo cmdInfo = {
         VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // sType
         NULL,                                             // pNext
@@ skipping 11 matching lines @@
     }
     return new GrVkCommandBuffer(cmdBuffer);
 }
 
 GrVkCommandBuffer::~GrVkCommandBuffer() {
     // Should have ended any render pass we're in the middle of
     SkASSERT(!fActiveRenderPass);
 }
 
 void GrVkCommandBuffer::invalidateState() {
-    fBoundVertexBuffer = 0;
+    fBoundVertexBuffer = VK_NULL_HANDLE;
     fBoundVertexBufferIsValid = false;
-    fBoundIndexBuffer = 0;
+    fBoundIndexBuffer = VK_NULL_HANDLE;
     fBoundIndexBufferIsValid = false;
+
+    memset(&fCachedViewport, 0, sizeof(VkViewport));
+    fCachedViewport.width = - 1.0f; // Viewport must have a width greater than 0
+
+    memset(&fCachedScissor, 0, sizeof(VkRect2D));
+    fCachedScissor.offset.x = -1; // Scissor offset must be greater that 0 to be valid
+
+    for (int i = 0; i < 4; ++i) {
+        fCachedBlendConstant[i] = -1.0;
+    }
 }
 
 void GrVkCommandBuffer::freeGPUData(const GrVkGpu* gpu) const {
     SkASSERT(!fIsActive);
     SkASSERT(!fActiveRenderPass);
     for (int i = 0; i < fTrackedResources.count(); ++i) {
         fTrackedResources[i]->unref(gpu);
     }
     
     // Destroy the fence, if any
@@ skipping 291 matching lines @@
                                                          VK_PIPELINE_BIND_POINT_GRAPHICS,
                                                          layout,
                                                          firstSet,
                                                          setCount,
                                                          descriptorSets,
                                                          dynamicOffsetCount,
                                                          dynamicOffsets));
     program->addUniformResources(*this);
 }
 
+void GrVkCommandBuffer::bindPipeline(const GrVkGpu* gpu, const GrVkPipeline* pipeline) {
+    SkASSERT(fIsActive);
+    SkASSERT(fActiveRenderPass);
+    GR_VK_CALL(gpu->vkInterface(), CmdBindPipeline(fCmdBuffer,
+                                                   VK_PIPELINE_BIND_POINT_GRAPHICS,
+                                                   pipeline->pipeline()));
+    addResource(pipeline);
+}
+
 void GrVkCommandBuffer::drawIndexed(const GrVkGpu* gpu,
                                     uint32_t indexCount,
                                     uint32_t instanceCount,
                                     uint32_t firstIndex,
                                     int32_t vertexOffset,
                                     uint32_t firstInstance) const {
     SkASSERT(fIsActive);
     SkASSERT(fActiveRenderPass);
     GR_VK_CALL(gpu->vkInterface(), CmdDrawIndexed(fCmdBuffer,
                                                   indexCount,
                                                   instanceCount,
                                                   firstIndex,
                                                   vertexOffset,
                                                   firstInstance));
 }
 
 void GrVkCommandBuffer::draw(const GrVkGpu* gpu,
                              uint32_t vertexCount,
                              uint32_t instanceCount,
                              uint32_t firstVertex,
                              uint32_t firstInstance) const {
     SkASSERT(fIsActive);
     SkASSERT(fActiveRenderPass);
     GR_VK_CALL(gpu->vkInterface(), CmdDraw(fCmdBuffer,
                                            vertexCount,
                                            instanceCount,
                                            firstVertex,
                                            firstInstance));
 }
+
+void GrVkCommandBuffer::setViewport(const GrVkGpu* gpu,
+                                    uint32_t firstViewport,
+                                    uint32_t viewportCount,
+                                    const VkViewport* viewports) {
+    SkASSERT(fIsActive);
+    SkASSERT(1 == viewportCount);
+    if (memcmp(viewports, &fCachedViewport, sizeof(VkViewport))) {
+        GR_VK_CALL(gpu->vkInterface(), CmdSetViewport(fCmdBuffer,
+                                                      firstViewport,
+                                                      viewportCount,
+                                                      viewports));
+        fCachedViewport = viewports[0];
+    }
+}
+
+void GrVkCommandBuffer::setScissor(const GrVkGpu* gpu,
+                                   uint32_t firstScissor,
+                                   uint32_t scissorCount,
+                                   const VkRect2D* scissors) {
+    SkASSERT(fIsActive);
+    SkASSERT(1 == scissorCount);
+    if (memcmp(scissors, &fCachedScissor, sizeof(VkRect2D))) {
+        GR_VK_CALL(gpu->vkInterface(), CmdSetScissor(fCmdBuffer,
+                                                     firstScissor,
+                                                     scissorCount,
+                                                     scissors));
+        fCachedScissor = scissors[0];
+    }
+}
+
+void GrVkCommandBuffer::setBlendConstants(const GrVkGpu* gpu,
+                                          const float blendConstants[4]) {
+    SkASSERT(fIsActive);
+    if (memcmp(blendConstants, fCachedBlendConstant, 4 * sizeof(float))) {
+        GR_VK_CALL(gpu->vkInterface(), CmdSetBlendConstants(fCmdBuffer, blendConstants));
+        memcpy(fCachedBlendConstant, blendConstants, 4 * sizeof(float));
+    }
+}