Use dynamic state from vulkan pipelines

src/gpu/vk/GrVkPipeline.cpp

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrVkPipeline.h"
 
 #include "GrGeometryProcessor.h"
 #include "GrPipeline.h"
-
+#include "GrVkCommandBuffer.h"
 #include "GrVkGpu.h"
 #include "GrVkProgramDesc.h"
 #include "GrVkRenderTarget.h"
 #include "GrVkUtil.h"
 
 static inline const VkFormat& attrib_type_to_vkformat(GrVertexAttribType type) {
     SkASSERT(type >= 0 && type < kGrVertexAttribTypeCount);
     static const VkFormat kFormats[kGrVertexAttribTypeCount] = {
         VK_FORMAT_R32_SFLOAT,          // kFloat_GrVertexAttribType
         VK_FORMAT_R32G32_SFLOAT,       // kVec2f_GrVertexAttribType
@@ skipping 158 matching lines @@
         stencilInfo->back.writeMask = stencilSettings.writeMask(face);
         stencilInfo->back.reference = stencilSettings.funcRef(face);
     }
     stencilInfo->minDepthBounds = 0.0f;
     stencilInfo->maxDepthBounds = 1.0f;
 }
 
 void setup_viewport_scissor_state(const GrVkGpu* gpu,
                                   const GrPipeline& pipeline,
                                   const GrVkRenderTarget* vkRT,
-                                  VkPipelineViewportStateCreateInfo* viewportInfo,
-                                  VkViewport* viewport,
-                                  VkRect2D* scissor) {
+                                  VkPipelineViewportStateCreateInfo* viewportInfo) {
     memset(viewportInfo, 0, sizeof(VkPipelineViewportStateCreateInfo));
     viewportInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
     viewportInfo->pNext = nullptr;
     viewportInfo->flags = 0;
 
-    viewport->x = 0.0f;
-    viewport->y = 0.0f;
-    viewport->width = SkIntToScalar(vkRT->width());
-    viewport->height = SkIntToScalar(vkRT->height());
-    viewport->minDepth = 0.0f;
-    viewport->maxDepth = 1.0f;
     viewportInfo->viewportCount = 1;
-    viewportInfo->pViewports = viewport;
+    viewportInfo->pViewports = nullptr; // This is set dynamically
 
-    const GrScissorState& scissorState = pipeline.getScissorState();
-    if (scissorState.enabled() && 
-        !scissorState.rect().contains(0, 0, vkRT->width(), vkRT->height())) {
-        // This all assumes the scissorState has previously been clipped to the device space render
-        // target. 
-        scissor->offset.x = scissorState.rect().fLeft;
-        scissor->extent.width = scissorState.rect().width();
-        if (kTopLeft_GrSurfaceOrigin == vkRT->origin()) {
-            scissor->offset.y = scissorState.rect().fTop;
-        } else {
-            SkASSERT(kBottomLeft_GrSurfaceOrigin == vkRT->origin());
-            scissor->offset.y = vkRT->height() - scissorState.rect().fBottom;
-        }
-        scissor->extent.height = scissorState.rect().height();
+    viewportInfo->scissorCount = 1;
+    viewportInfo->pScissors = nullptr; // This is set dynamically
 
-        viewportInfo->scissorCount = 1;
-        viewportInfo->pScissors = scissor;
-        SkASSERT(scissor->offset.x >= 0);
-        SkASSERT(scissor->offset.x + scissor->extent.width <= (uint32_t)vkRT->width());
-        SkASSERT(scissor->offset.y >= 0);
-        SkASSERT(scissor->offset.y + scissor->extent.height <= (uint32_t)vkRT->height());
-    } else {
-        scissor->extent.width = vkRT->width();
-        scissor->extent.height = vkRT->height();
-        scissor->offset.x = 0;
-        scissor->offset.y = 0;
-        viewportInfo->scissorCount = 1;
-        viewportInfo->pScissors = scissor;
-    }
     SkASSERT(viewportInfo->viewportCount == viewportInfo->scissorCount);
 }
 
 void setup_multisample_state(const GrPipeline& pipeline,
                              VkPipelineMultisampleStateCreateInfo* multisampleInfo) {
     memset(multisampleInfo, 0, sizeof(VkPipelineMultisampleStateCreateInfo));
     multisampleInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
     multisampleInfo->pNext = nullptr;
     multisampleInfo->flags = 0;
     int numSamples = pipeline.getRenderTarget()->numColorSamples();
@@ skipping 92 matching lines @@
         false,
     };
     return gCoeffReferencesBlendConst[coeff];
     GR_STATIC_ASSERT(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gCoeffReferencesBlendConst));
     // Individual enum asserts already made in blend_coeff_to_vk_blend
 }
 
 void setup_color_blend_state(const GrVkGpu* gpu,
                              const GrPipeline& pipeline,
                              VkPipelineColorBlendStateCreateInfo* colorBlendInfo,
-                             VkPipelineColorBlendAttachmentState* attachmentState) {
+                             VkPipelineColorBlendAttachmentState* attachmentState,
+                             bool* usesBlendConstant) {
     GrXferProcessor::BlendInfo blendInfo;
     pipeline.getXferProcessor().getBlendInfo(&blendInfo);
 
     GrBlendEquation equation = blendInfo.fEquation;
     GrBlendCoeff srcCoeff = blendInfo.fSrcBlend;
     GrBlendCoeff dstCoeff = blendInfo.fDstBlend;
     bool blendOff = (kAdd_GrBlendEquation == equation || kSubtract_GrBlendEquation == equation) &&
                     kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff;
 
     memset(attachmentState, 0, sizeof(VkPipelineColorBlendAttachmentState));
@@ skipping 14 matching lines @@
                                           VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
     }
 
     memset(colorBlendInfo, 0, sizeof(VkPipelineColorBlendStateCreateInfo));
     colorBlendInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
     colorBlendInfo->pNext = nullptr;
     colorBlendInfo->flags = 0;
     colorBlendInfo->logicOpEnable = VK_FALSE;
     colorBlendInfo->attachmentCount = 1;
     colorBlendInfo->pAttachments = attachmentState;
-    if (blend_coeff_refs_constant(srcCoeff) || blend_coeff_refs_constant(dstCoeff)) {
-        GrColorToRGBAFloat(blendInfo.fBlendConstant, colorBlendInfo->blendConstants);
-    }
+    // colorBlendInfo->blendConstants is set dynamically

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

SkASSERT(usesBlendConstant);

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

removed

+    *usesBlendConstant = blend_coeff_refs_constant(srcCoeff) || blend_coeff_refs_constant(dstCoeff);
 }
 
 VkCullModeFlags draw_face_to_vk_cull_mode(GrPipelineBuilder::DrawFace drawFace) {
     // Assumes that we've set the front face to be ccw
     static const VkCullModeFlags gTable[] = {
         VK_CULL_MODE_NONE,              // kBoth_DrawFace
         VK_CULL_MODE_BACK_BIT,          // kCCW_DrawFace, cull back face
         VK_CULL_MODE_FRONT_BIT,         // kCW_DrawFace, cull front face
     };
     GR_STATIC_ASSERT(0 == GrPipelineBuilder::kBoth_DrawFace);
@@ skipping 18 matching lines @@
     rasterInfo->frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
     rasterInfo->depthBiasEnable = VK_FALSE;
     rasterInfo->depthBiasConstantFactor = 0.0f;
     rasterInfo->depthBiasClamp = 0.0f;
     rasterInfo->depthBiasSlopeFactor = 0.0f;
     rasterInfo->lineWidth = 1.0f;
 }
 
 void setup_dynamic_state(const GrVkGpu* gpu,
                          const GrPipeline& pipeline,
-                         VkPipelineDynamicStateCreateInfo* dynamicInfo) {
+                         bool usingBlendConstant,
+                         VkPipelineDynamicStateCreateInfo* dynamicInfo,
+                         VkDynamicState* dynamicStates) {
     memset(dynamicInfo, 0, sizeof(VkPipelineDynamicStateCreateInfo));
     dynamicInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
-    // TODO: mask out any state we might want to set dynamically
-    dynamicInfo->dynamicStateCount = 0;
+    dynamicInfo->pNext = VK_NULL_HANDLE;
+    dynamicInfo->flags = 0;
+    dynamicStates[0] = VK_DYNAMIC_STATE_VIEWPORT;
+    dynamicStates[1] = VK_DYNAMIC_STATE_SCISSOR;
+    dynamicStates[2] = VK_DYNAMIC_STATE_BLEND_CONSTANTS;
+    // If we aren't using the blend constant we don't set it on the command buffer where is an error

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

This comment is a little confusing. Suggestion: "If we aren't using the blend
constant, we don't include it here. Otherwise we may get an error on the command
buffer."

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

always using dynamic blendConstant now

+    // if you say you are using it here.
+    dynamicInfo->dynamicStateCount = usingBlendConstant ? 3 : 2;
+    dynamicInfo->pDynamicStates = dynamicStates;
 }
 
 GrVkPipeline* GrVkPipeline::Create(GrVkGpu* gpu, const GrPipeline& pipeline,
                                    const GrPrimitiveProcessor& primProc,
                                    VkPipelineShaderStageCreateInfo* shaderStageInfo,
                                    int shaderStageCount,
                                    GrPrimitiveType primitiveType,
                                    const GrVkRenderPass& renderPass,
                                    VkPipelineLayout layout,
                                    VkPipelineCache cache) {
     VkPipelineVertexInputStateCreateInfo vertexInputInfo;
     VkVertexInputBindingDescription bindingDesc;
     // TODO: allocate this based on VkPhysicalDeviceLimits::maxVertexInputAttributes
     static const int kMaxVertexAttributes = 16;
     static VkVertexInputAttributeDescription attributeDesc[kMaxVertexAttributes];
     setup_vertex_input_state(primProc, &vertexInputInfo, &bindingDesc, 1,
                              attributeDesc, kMaxVertexAttributes);
 
     VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo;
     setup_input_assembly_state(primitiveType, &inputAssemblyInfo);
 
     VkPipelineDepthStencilStateCreateInfo depthStencilInfo;
     setup_depth_stencil_state(gpu, pipeline.getStencil(), &depthStencilInfo);
 
     GrRenderTarget* rt = pipeline.getRenderTarget();
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(rt);
     VkPipelineViewportStateCreateInfo viewportInfo;
-    VkViewport viewport;
-    VkRect2D scissor;
-    setup_viewport_scissor_state(gpu, pipeline, vkRT, &viewportInfo, &viewport, &scissor);
+    setup_viewport_scissor_state(gpu, pipeline, vkRT, &viewportInfo);
 
     VkPipelineMultisampleStateCreateInfo multisampleInfo;
     setup_multisample_state(pipeline, &multisampleInfo);
 
     // We will only have one color attachment per pipeline.
     VkPipelineColorBlendAttachmentState attachmentStates[1];
     VkPipelineColorBlendStateCreateInfo colorBlendInfo;
-    setup_color_blend_state(gpu, pipeline, &colorBlendInfo, attachmentStates);
+    bool usesBlendConstant;
+    setup_color_blend_state(gpu, pipeline, &colorBlendInfo, attachmentStates, &usesBlendConstant);
 
     VkPipelineRasterizationStateCreateInfo rasterInfo;
     setup_raster_state(gpu, pipeline, &rasterInfo);
 
+    VkDynamicState dynamicStates[3];
     VkPipelineDynamicStateCreateInfo dynamicInfo;
-    setup_dynamic_state(gpu, pipeline, &dynamicInfo);
+    setup_dynamic_state(gpu, pipeline, usesBlendConstant, &dynamicInfo, dynamicStates);
 
     VkGraphicsPipelineCreateInfo pipelineCreateInfo;
     memset(&pipelineCreateInfo, 0, sizeof(VkGraphicsPipelineCreateInfo));
     pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
     pipelineCreateInfo.pNext = nullptr;
     pipelineCreateInfo.flags = 0;
     pipelineCreateInfo.stageCount = shaderStageCount;
     pipelineCreateInfo.pStages = shaderStageInfo;
     pipelineCreateInfo.pVertexInputState = &vertexInputInfo;
     pipelineCreateInfo.pInputAssemblyState = &inputAssemblyInfo;
@@ skipping 20 matching lines @@
     }
 
     return new GrVkPipeline(vkPipeline);
 }
 
 void GrVkPipeline::freeGPUData(const GrVkGpu* gpu) const {
     GR_VK_CALL(gpu->vkInterface(), DestroyPipeline(gpu->device(), fPipeline, nullptr));
 }
 
 
+void set_dynamic_scissor_state(GrVkGpu* gpu,
+                               GrVkCommandBuffer* cmdBuffer,
+                               const GrPipeline& pipeline,
+                               const GrRenderTarget& target) {
+    // We always use one scissor and if it is disabled we just make it the size of the RT
+    const GrScissorState& scissorState = pipeline.getScissorState();
+    VkRect2D scissor;
+    if (scissorState.enabled() &&
+        !scissorState.rect().contains(0, 0, target.width(), target.height())) {
+        // This all assumes the scissorState has previously been clipped to the device space render
+        // target. 
+        scissor.offset.x = scissorState.rect().fLeft;
+        scissor.extent.width = scissorState.rect().width();
+        if (kTopLeft_GrSurfaceOrigin == target.origin()) {
+            scissor.offset.y = scissorState.rect().fTop;
+        } else {
+            SkASSERT(kBottomLeft_GrSurfaceOrigin == target.origin());
+            scissor.offset.y = target.height() - scissorState.rect().fBottom;
+        }
+        scissor.extent.height = scissorState.rect().height();
+
+        SkASSERT(scissor.offset.x >= 0);
+        SkASSERT(scissor.offset.x + scissor.extent.width <= (uint32_t)target.width());
+        SkASSERT(scissor.offset.y >= 0);
+        SkASSERT(scissor.offset.y + scissor.extent.height <= (uint32_t)target.height());
+    } else {
+        scissor.extent.width = target.width();
+        scissor.extent.height = target.height();
+        scissor.offset.x = 0;
+        scissor.offset.y = 0;
+    }
+    cmdBuffer->setScissor(gpu, 0, 1, &scissor);
+}
+
+void set_dynamic_viewport_state(GrVkGpu* gpu,
+                                GrVkCommandBuffer* cmdBuffer,
+                                const GrRenderTarget& target) {
+    // We always use one viewport the size of the RT
+    VkViewport viewport;
+    viewport.x = 0.0f;
+    viewport.y = 0.0f;
+    viewport.width = SkIntToScalar(target.width());
+    viewport.height = SkIntToScalar(target.height());
+    viewport.minDepth = 0.0f;
+    viewport.maxDepth = 1.0f;
+    cmdBuffer->setViewport(gpu, 0, 1, &viewport);
+}
+
+void set_dynamic_blend_constant_state(GrVkGpu* gpu,
+                                     GrVkCommandBuffer* cmdBuffer,
+                                     const GrPipeline& pipeline) {
+    GrXferProcessor::BlendInfo blendInfo;
+    pipeline.getXferProcessor().getBlendInfo(&blendInfo);
+    GrBlendCoeff srcCoeff = blendInfo.fSrcBlend;
+    GrBlendCoeff dstCoeff = blendInfo.fDstBlend;
+    if (blend_coeff_refs_constant(srcCoeff) || blend_coeff_refs_constant(dstCoeff)) {
+        float floatColors[4];
+        GrColorToRGBAFloat(blendInfo.fBlendConstant, floatColors);
+        cmdBuffer->setBlendConstants(gpu, floatColors);
+    }
+}
+
+
+                                          
+void GrVkPipeline::SetDynamicState(GrVkGpu* gpu,
+                                   GrVkCommandBuffer* cmdBuffer,
+                                   const GrPipeline& pipeline) {
+    const GrRenderTarget& target = *pipeline.getRenderTarget();
+    set_dynamic_scissor_state(gpu, cmdBuffer, pipeline, target);

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

This is fine for now, but when you add the change to cache the pipeline, you may
want to make sure they only get set when they change. Other you're inserting
redundant instructions into the command buffer.

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

added caching

+    set_dynamic_viewport_state(gpu, cmdBuffer, target);
+    set_dynamic_blend_constant_state(gpu, cmdBuffer, pipeline);
+}