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"
@@ skipping 337 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) {

[jvanverth1, 2016/03/18 15:02:26]

I'm curious why you moved this from the header.

[egdaniel, 2016/03/18 19:29:58]

all the other command buffer functions were in the cpp, this one didn't seem to
be any more special than the rest.

+    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);
+    GR_VK_CALL(gpu->vkInterface(), CmdSetViewport(fCmdBuffer,
+                                                  firstViewport,
+                                                  viewportCount,
+                                                  viewports));
+}
+
+void GrVkCommandBuffer::setScissor(const GrVkGpu* gpu,
+                                   uint32_t firstScissor,
+                                   uint32_t scissorCount,
+                                   const VkRect2D* scissors) {
+    SkASSERT(fIsActive);
+    GR_VK_CALL(gpu->vkInterface(), CmdSetScissor(fCmdBuffer,
+                                                 firstScissor,
+                                                 scissorCount,
+                                                 scissors));
+}
+
+void GrVkCommandBuffer::setBlendConstants(const GrVkGpu* gpu,
+                                          const float blendConstants[4]) {
+    SkASSERT(fIsActive);
+    GR_VK_CALL(gpu->vkInterface(), CmdSetBlendConstants(fCmdBuffer, blendConstants));
+}