From: Jason Ekstrand Date: Wed, 7 Oct 2015 00:21:44 +0000 (-0700) Subject: vk/0.170.2: Switch to the new dynamic state model X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=daf68a9465050c798012125e7150017c09576e0f;p=mesa.git vk/0.170.2: Switch to the new dynamic state model --- diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 4fe9e67fabc..abf87d81e83 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -101,10 +101,6 @@ VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout) VK_DEFINE_NONDISP_HANDLE(VkSampler) VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool) VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) -VK_DEFINE_NONDISP_HANDLE(VkDynamicViewportState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicColorBlendState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthStencilState) VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) VK_DEFINE_NONDISP_HANDLE(VkCmdPool) @@ -683,6 +679,22 @@ typedef enum { VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF } VkBlendOp; +typedef enum { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + VK_DYNAMIC_STATE_NUM = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + typedef enum { VK_TEX_FILTER_NEAREST = 0, VK_TEX_FILTER_LINEAR = 1, @@ -1068,6 +1080,13 @@ typedef enum { } VkCmdBufferResetFlagBits; typedef VkFlags VkCmdBufferResetFlags; +typedef enum { + VK_STENCIL_FACE_NONE = 0, + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; + typedef enum { VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, } VkQueryControlFlagBits; @@ -1616,6 +1635,9 @@ typedef struct { VkStructureType sType; const void* pNext; uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; } VkPipelineViewportStateCreateInfo; typedef struct { @@ -1626,6 +1648,11 @@ typedef struct { VkFillMode fillMode; VkCullMode cullMode; VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBias; + float depthBiasClamp; + float slopeScaledDepthBias; + float lineWidth; } VkPipelineRasterStateCreateInfo; typedef struct { @@ -1642,6 +1669,9 @@ typedef struct { VkStencilOp stencilPassOp; VkStencilOp stencilDepthFailOp; VkCompareOp stencilCompareOp; + uint32_t stencilCompareMask; + uint32_t stencilWriteMask; + uint32_t stencilReference; } VkStencilOpState; typedef struct { @@ -1654,6 +1684,8 @@ typedef struct { VkBool32 stencilTestEnable; VkStencilOpState front; VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; } VkPipelineDepthStencilStateCreateInfo; typedef struct { @@ -1671,12 +1703,21 @@ typedef struct { VkStructureType sType; const void* pNext; VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; VkBool32 logicOpEnable; VkLogicOp logicOp; uint32_t attachmentCount; const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConst[4]; } VkPipelineColorBlendStateCreateInfo; +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + typedef struct { VkStructureType sType; const void* pNext; @@ -1690,6 +1731,7 @@ typedef struct { const VkPipelineMultisampleStateCreateInfo* pMultisampleState; const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; VkPipelineCreateFlags flags; VkPipelineLayout layout; VkRenderPass renderPass; @@ -1798,40 +1840,6 @@ typedef struct { uint32_t count; } VkCopyDescriptorSet; -typedef struct { - VkStructureType sType; - const void* pNext; - uint32_t viewportAndScissorCount; - const VkViewport* pViewports; - const VkRect2D* pScissors; -} VkDynamicViewportStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float depthBias; - float depthBiasClamp; - float slopeScaledDepthBias; - float lineWidth; -} VkDynamicRasterStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float blendConst[4]; -} VkDynamicColorBlendStateCreateInfo; - -typedef struct { - VkStructureType sType; - const void* pNext; - float minDepthBounds; - float maxDepthBounds; - uint32_t stencilReadMask; - uint32_t stencilWriteMask; - uint32_t stencilFrontRef; - uint32_t stencilBackRef; -} VkDynamicDepthStencilStateCreateInfo; - typedef struct { VkStructureType sType; const void* pNext; @@ -2143,14 +2151,6 @@ typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescripto typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets); typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); -typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState); -typedef void (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState); -typedef void (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState); -typedef void (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState); -typedef void (VKAPI *PFN_vkDestroyDynamicDepthStencilState)(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState); typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); @@ -2165,10 +2165,15 @@ typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags); typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void (VKAPI *PFN_vkCmdBindDynamicViewportState)(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState); -typedef void (VKAPI *PFN_vkCmdBindDynamicRasterState)(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState); -typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState); -typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState); +typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth); +typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias); +typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConst[4]); +typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask); +typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask); +typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference); typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); @@ -2645,42 +2650,6 @@ VkResult VKAPI vkUpdateDescriptorSets( uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); -VkResult VKAPI vkCreateDynamicViewportState( - VkDevice device, - const VkDynamicViewportStateCreateInfo* pCreateInfo, - VkDynamicViewportState* pState); - -void VKAPI vkDestroyDynamicViewportState( - VkDevice device, - VkDynamicViewportState dynamicViewportState); - -VkResult VKAPI vkCreateDynamicRasterState( - VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState); - -void VKAPI vkDestroyDynamicRasterState( - VkDevice device, - VkDynamicRasterState dynamicRasterState); - -VkResult VKAPI vkCreateDynamicColorBlendState( - VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState); - -void VKAPI vkDestroyDynamicColorBlendState( - VkDevice device, - VkDynamicColorBlendState dynamicColorBlendState); - -VkResult VKAPI vkCreateDynamicDepthStencilState( - VkDevice device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState); - -void VKAPI vkDestroyDynamicDepthStencilState( - VkDevice device, - VkDynamicDepthStencilState dynamicDepthStencilState); - VkResult VKAPI vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, @@ -2743,21 +2712,49 @@ void VKAPI vkCmdBindPipeline( VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -void VKAPI vkCmdBindDynamicViewportState( +void VKAPI vkCmdSetViewport( + VkCmdBuffer cmdBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +void VKAPI vkCmdSetScissor( + VkCmdBuffer cmdBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +void VKAPI vkCmdSetLineWidth( + VkCmdBuffer cmdBuffer, + float lineWidth); + +void VKAPI vkCmdSetDepthBias( + VkCmdBuffer cmdBuffer, + float depthBias, + float depthBiasClamp, + float slopeScaledDepthBias); + +void VKAPI vkCmdSetBlendConstants( + VkCmdBuffer cmdBuffer, + const float blendConst[4]); + +void VKAPI vkCmdSetDepthBounds( VkCmdBuffer cmdBuffer, - VkDynamicViewportState dynamicViewportState); + float minDepthBounds, + float maxDepthBounds); -void VKAPI vkCmdBindDynamicRasterState( +void VKAPI vkCmdSetStencilCompareMask( VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState); + VkStencilFaceFlags faceMask, + uint32_t stencilCompareMask); -void VKAPI vkCmdBindDynamicColorBlendState( +void VKAPI vkCmdSetStencilWriteMask( VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState); + VkStencilFaceFlags faceMask, + uint32_t stencilWriteMask); -void VKAPI vkCmdBindDynamicDepthStencilState( +void VKAPI vkCmdSetStencilReference( VkCmdBuffer cmdBuffer, - VkDynamicDepthStencilState dynamicDepthStencilState); + VkStencilFaceFlags faceMask, + uint32_t stencilReference); void VKAPI vkCmdBindDescriptorSets( VkCmdBuffer cmdBuffer, diff --git a/src/vulkan/anv_cmd_buffer.c b/src/vulkan/anv_cmd_buffer.c index 78b17ea15ee..8486bd05a2c 100644 --- a/src/vulkan/anv_cmd_buffer.c +++ b/src/vulkan/anv_cmd_buffer.c @@ -113,22 +113,16 @@ anv_dynamic_state_copy(struct anv_dynamic_state *dest, static void anv_cmd_state_init(struct anv_cmd_state *state) { - state->rs_state = NULL; - state->vp_state = NULL; - state->cb_state = NULL; - state->ds_state = NULL; memset(&state->state_vf, 0, sizeof(state->state_vf)); memset(&state->descriptors, 0, sizeof(state->descriptors)); memset(&state->push_constants, 0, sizeof(state->push_constants)); - state->dirty = 0; + state->dirty = ~0; state->vb_dirty = 0; state->descriptors_dirty = 0; state->push_constants_dirty = 0; state->pipeline = NULL; - state->vp_state = NULL; - state->rs_state = NULL; - state->ds_state = NULL; + state->dynamic = default_dynamic_state; state->gen7.index_buffer = NULL; } @@ -333,48 +327,128 @@ void anv_CmdBindPipeline( } } -void anv_CmdBindDynamicViewportState( +void anv_CmdSetViewport( VkCmdBuffer cmdBuffer, - VkDynamicViewportState dynamicViewportState) + uint32_t viewportCount, + const VkViewport* pViewports) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); - ANV_FROM_HANDLE(anv_dynamic_vp_state, vp_state, dynamicViewportState); - cmd_buffer->state.vp_state = vp_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_VP_DIRTY; + cmd_buffer->state.dynamic.viewport.count = viewportCount; + memcpy(cmd_buffer->state.dynamic.viewport.viewports, + pViewports, viewportCount * sizeof(*pViewports)); + + cmd_buffer->state.dirty |= ANV_DYNAMIC_VIEWPORT_DIRTY; +} + +void anv_CmdSetScissor( + VkCmdBuffer cmdBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + cmd_buffer->state.dynamic.scissor.count = scissorCount; + memcpy(cmd_buffer->state.dynamic.scissor.scissors, + pScissors, scissorCount * sizeof(*pScissors)); + + cmd_buffer->state.dirty |= ANV_DYNAMIC_SCISSOR_DIRTY; +} + +void anv_CmdSetLineWidth( + VkCmdBuffer cmdBuffer, + float lineWidth) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + cmd_buffer->state.dynamic.line_width = lineWidth; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_LINE_WIDTH_DIRTY; +} + +void anv_CmdSetDepthBias( + VkCmdBuffer cmdBuffer, + float depthBias, + float depthBiasClamp, + float slopeScaledDepthBias) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + cmd_buffer->state.dynamic.depth_bias.bias = depthBias; + cmd_buffer->state.dynamic.depth_bias.clamp = depthBiasClamp; + cmd_buffer->state.dynamic.depth_bias.slope_scaled = slopeScaledDepthBias; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_DEPTH_BIAS_DIRTY; +} + +void anv_CmdSetBlendConstants( + VkCmdBuffer cmdBuffer, + const float blendConst[4]) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + memcpy(cmd_buffer->state.dynamic.blend_constants, + blendConst, sizeof(float) * 4); + + cmd_buffer->state.dirty |= ANV_DYNAMIC_BLEND_CONSTANTS_DIRTY; +} + +void anv_CmdSetDepthBounds( + VkCmdBuffer cmdBuffer, + float minDepthBounds, + float maxDepthBounds) +{ + ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); + + cmd_buffer->state.dynamic.depth_bounds.min = minDepthBounds; + cmd_buffer->state.dynamic.depth_bounds.max = maxDepthBounds; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_DEPTH_BOUNDS_DIRTY; } -void anv_CmdBindDynamicRasterState( +void anv_CmdSetStencilCompareMask( VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState) + VkStencilFaceFlags faceMask, + uint32_t stencilCompareMask) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); - ANV_FROM_HANDLE(anv_dynamic_rs_state, rs_state, dynamicRasterState); - cmd_buffer->state.rs_state = rs_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_RS_DIRTY; + if (faceMask & VK_STENCIL_FACE_FRONT_BIT) + cmd_buffer->state.dynamic.stencil_compare_mask.front = stencilCompareMask; + if (faceMask & VK_STENCIL_FACE_BACK_BIT) + cmd_buffer->state.dynamic.stencil_compare_mask.back = stencilCompareMask; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_STENCIL_COMPARE_MASK_DIRTY; } -void anv_CmdBindDynamicColorBlendState( +void anv_CmdSetStencilWriteMask( VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState) + VkStencilFaceFlags faceMask, + uint32_t stencilWriteMask) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); - ANV_FROM_HANDLE(anv_dynamic_cb_state, cb_state, dynamicColorBlendState); - cmd_buffer->state.cb_state = cb_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_CB_DIRTY; + if (faceMask & VK_STENCIL_FACE_FRONT_BIT) + cmd_buffer->state.dynamic.stencil_write_mask.front = stencilWriteMask; + if (faceMask & VK_STENCIL_FACE_BACK_BIT) + cmd_buffer->state.dynamic.stencil_write_mask.back = stencilWriteMask; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_STENCIL_WRITE_MASK_DIRTY; } -void anv_CmdBindDynamicDepthStencilState( +void anv_CmdSetStencilReference( VkCmdBuffer cmdBuffer, - VkDynamicDepthStencilState dynamicDepthStencilState) + VkStencilFaceFlags faceMask, + uint32_t stencilReference) { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, cmdBuffer); - ANV_FROM_HANDLE(anv_dynamic_ds_state, ds_state, dynamicDepthStencilState); - cmd_buffer->state.ds_state = ds_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_DS_DIRTY; + if (faceMask & VK_STENCIL_FACE_FRONT_BIT) + cmd_buffer->state.dynamic.stencil_reference.front = stencilReference; + if (faceMask & VK_STENCIL_FACE_BACK_BIT) + cmd_buffer->state.dynamic.stencil_reference.back = stencilReference; + + cmd_buffer->state.dirty |= ANV_DYNAMIC_STENCIL_REFERENCE_DIRTY; } void anv_CmdBindDescriptorSets( @@ -736,6 +810,148 @@ anv_cmd_buffer_begin_subpass(struct anv_cmd_buffer *cmd_buffer, } } +static void +emit_viewport_state(struct anv_cmd_buffer *cmd_buffer, + uint32_t count, const VkViewport *viewports) +{ + struct anv_state sf_clip_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, count * 64, 64); + struct anv_state cc_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, count * 8, 32); + + for (uint32_t i = 0; i < count; i++) { + const VkViewport *vp = &viewports[i]; + + /* The gen7 state struct has just the matrix and guardband fields, the + * gen8 struct adds the min/max viewport fields. */ + struct GEN8_SF_CLIP_VIEWPORT sf_clip_viewport = { + .ViewportMatrixElementm00 = vp->width / 2, + .ViewportMatrixElementm11 = vp->height / 2, + .ViewportMatrixElementm22 = (vp->maxDepth - vp->minDepth) / 2, + .ViewportMatrixElementm30 = vp->originX + vp->width / 2, + .ViewportMatrixElementm31 = vp->originY + vp->height / 2, + .ViewportMatrixElementm32 = (vp->maxDepth + vp->minDepth) / 2, + .XMinClipGuardband = -1.0f, + .XMaxClipGuardband = 1.0f, + .YMinClipGuardband = -1.0f, + .YMaxClipGuardband = 1.0f, + .XMinViewPort = vp->originX, + .XMaxViewPort = vp->originX + vp->width - 1, + .YMinViewPort = vp->originY, + .YMaxViewPort = vp->originY + vp->height - 1, + }; + + struct GEN7_CC_VIEWPORT cc_viewport = { + .MinimumDepth = vp->minDepth, + .MaximumDepth = vp->maxDepth + }; + + GEN8_SF_CLIP_VIEWPORT_pack(NULL, sf_clip_state.map + i * 64, + &sf_clip_viewport); + GEN7_CC_VIEWPORT_pack(NULL, cc_state.map + i * 32, &cc_viewport); + } + + anv_batch_emit(&cmd_buffer->batch, + GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC, + .CCViewportPointer = cc_state.offset); + anv_batch_emit(&cmd_buffer->batch, + GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP, + .SFClipViewportPointer = sf_clip_state.offset); +} + +void +anv_cmd_buffer_emit_viewport(struct anv_cmd_buffer *cmd_buffer) +{ + if (cmd_buffer->state.dynamic.viewport.count > 0) { + emit_viewport_state(cmd_buffer, cmd_buffer->state.dynamic.viewport.count, + cmd_buffer->state.dynamic.viewport.viewports); + } else { + /* If viewport count is 0, this is taken to mean "use the default" */ + emit_viewport_state(cmd_buffer, 1, + &(VkViewport) { + .originX = 0.0f, + .originY = 0.0f, + .width = cmd_buffer->state.framebuffer->width, + .height = cmd_buffer->state.framebuffer->height, + .minDepth = 0.0f, + .maxDepth = 1.0f, + }); + } +} + +static inline int64_t +clamp_int64(int64_t x, int64_t min, int64_t max) +{ + if (x < min) + return min; + else if (x < max) + return x; + else + return max; +} + +static void +emit_scissor_state(struct anv_cmd_buffer *cmd_buffer, + uint32_t count, const VkRect2D *scissors) +{ + struct anv_state scissor_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, count * 32, 32); + + for (uint32_t i = 0; i < count; i++) { + const VkRect2D *s = &scissors[i]; + + /* Since xmax and ymax are inclusive, we have to have xmax < xmin or + * ymax < ymin for empty clips. In case clip x, y, width height are all + * 0, the clamps below produce 0 for xmin, ymin, xmax, ymax, which isn't + * what we want. Just special case empty clips and produce a canonical + * empty clip. */ + static const struct GEN7_SCISSOR_RECT empty_scissor = { + .ScissorRectangleYMin = 1, + .ScissorRectangleXMin = 1, + .ScissorRectangleYMax = 0, + .ScissorRectangleXMax = 0 + }; + + const int max = 0xffff; + struct GEN7_SCISSOR_RECT scissor = { + /* Do this math using int64_t so overflow gets clamped correctly. */ + .ScissorRectangleYMin = clamp_int64(s->offset.y, 0, max), + .ScissorRectangleXMin = clamp_int64(s->offset.x, 0, max), + .ScissorRectangleYMax = clamp_int64((uint64_t) s->offset.y + s->extent.height - 1, 0, max), + .ScissorRectangleXMax = clamp_int64((uint64_t) s->offset.x + s->extent.width - 1, 0, max) + }; + + if (s->extent.width <= 0 || s->extent.height <= 0) { + GEN7_SCISSOR_RECT_pack(NULL, scissor_state.map + i * 32, + &empty_scissor); + } else { + GEN7_SCISSOR_RECT_pack(NULL, scissor_state.map + i * 32, &scissor); + } + } + + anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_SCISSOR_STATE_POINTERS, + .ScissorRectPointer = scissor_state.offset); +} + +void +anv_cmd_buffer_emit_scissor(struct anv_cmd_buffer *cmd_buffer) +{ + if (cmd_buffer->state.dynamic.scissor.count > 0) { + emit_scissor_state(cmd_buffer, cmd_buffer->state.dynamic.scissor.count, + cmd_buffer->state.dynamic.scissor.scissors); + } else { + /* Emit a default scissor based on the currently bound framebuffer */ + emit_scissor_state(cmd_buffer, 1, + &(VkRect2D) { + .offset = { .x = 0, .y = 0, }, + .extent = { + .width = cmd_buffer->state.framebuffer->width, + .height = cmd_buffer->state.framebuffer->height, + }, + }); + } +} + void anv_CmdSetEvent( VkCmdBuffer cmdBuffer, VkEvent event, diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index b10cc4512b4..aec900065e6 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -389,7 +389,7 @@ VkResult anv_GetPhysicalDeviceLimits( .primitiveRestartForPatches = UINT32_MAX, .maxSamplerLodBias = 16, .maxSamplerAnisotropy = 16, - .maxViewports = 16, + .maxViewports = MAX_VIEWPORTS, .maxDynamicViewportStates = UINT32_MAX, .maxViewportDimensions = { (1 << 14), (1 << 14) }, .viewportBoundsRange = { -1.0, 1.0 }, /* FIXME */ @@ -1778,6 +1778,8 @@ VkResult anv_UpdateDescriptorSets( // State object functions +#if 0 + static inline int64_t clamp_int64(int64_t x, int64_t min, int64_t max) { @@ -1949,6 +1951,8 @@ void anv_DestroyDynamicDepthStencilState( anv_device_free(device, ds_state); } +#endif + VkResult anv_CreateFramebuffer( VkDevice _device, const VkFramebufferCreateInfo* pCreateInfo, @@ -1976,27 +1980,6 @@ VkResult anv_CreateFramebuffer( framebuffer->height = pCreateInfo->height; framebuffer->layers = pCreateInfo->layers; - anv_CreateDynamicViewportState(anv_device_to_handle(device), - &(VkDynamicViewportStateCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, - .viewportAndScissorCount = 1, - .pViewports = (VkViewport[]) { - { - .originX = 0, - .originY = 0, - .width = pCreateInfo->width, - .height = pCreateInfo->height, - .minDepth = 0, - .maxDepth = 1 - }, - }, - .pScissors = (VkRect2D[]) { - { { 0, 0 }, - { pCreateInfo->width, pCreateInfo->height } }, - } - }, - &framebuffer->vp_state); - *pFramebuffer = anv_framebuffer_to_handle(framebuffer); return VK_SUCCESS; @@ -2009,8 +1992,6 @@ void anv_DestroyFramebuffer( ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_framebuffer, fb, _fb); - anv_DestroyDynamicViewportState(anv_device_to_handle(device), - fb->vp_state); anv_device_free(device, fb); } diff --git a/src/vulkan/anv_meta.c b/src/vulkan/anv_meta.c index c0e4112f363..565575ab219 100644 --- a/src/vulkan/anv_meta.c +++ b/src/vulkan/anv_meta.c @@ -293,20 +293,22 @@ struct anv_saved_state { struct anv_vertex_binding old_vertex_bindings[NUM_VB_USED]; struct anv_descriptor_set *old_descriptor_set0; struct anv_pipeline *old_pipeline; - struct anv_dynamic_ds_state *old_ds_state; - struct anv_dynamic_cb_state *old_cb_state; + uint32_t dynamic_flags; + struct anv_dynamic_state dynamic; }; static void anv_cmd_buffer_save(struct anv_cmd_buffer *cmd_buffer, - struct anv_saved_state *state) + struct anv_saved_state *state, + uint32_t dynamic_state) { state->old_pipeline = cmd_buffer->state.pipeline; state->old_descriptor_set0 = cmd_buffer->state.descriptors[0].set; memcpy(state->old_vertex_bindings, cmd_buffer->state.vertex_bindings, sizeof(state->old_vertex_bindings)); - state->old_ds_state = cmd_buffer->state.ds_state; - state->old_cb_state = cmd_buffer->state.cb_state; + state->dynamic_flags = dynamic_state; + anv_dynamic_state_copy(&state->dynamic, &cmd_buffer->state.dynamic, + dynamic_state); } static void @@ -322,15 +324,9 @@ anv_cmd_buffer_restore(struct anv_cmd_buffer *cmd_buffer, cmd_buffer->state.dirty |= ANV_CMD_BUFFER_PIPELINE_DIRTY; cmd_buffer->state.descriptors_dirty |= VK_SHADER_STAGE_VERTEX_BIT; - if (cmd_buffer->state.ds_state != state->old_ds_state) { - cmd_buffer->state.ds_state = state->old_ds_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_DS_DIRTY; - } - - if (cmd_buffer->state.cb_state != state->old_cb_state) { - cmd_buffer->state.cb_state = state->old_cb_state; - cmd_buffer->state.dirty |= ANV_CMD_BUFFER_CB_DIRTY; - } + anv_dynamic_state_copy(&cmd_buffer->state.dynamic, &state->dynamic, + state->dynamic_flags); + cmd_buffer->state.dirty |= state->dynamic_flags; } struct vue_header { @@ -396,23 +392,6 @@ meta_emit_clear(struct anv_cmd_buffer *cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, device->meta_state.clear.pipeline); - /* We don't need anything here, only set if not already set. */ - if (cmd_buffer->state.rs_state == NULL) - anv_CmdBindDynamicRasterState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.rs_state); - - if (cmd_buffer->state.vp_state == NULL) - anv_CmdBindDynamicViewportState(anv_cmd_buffer_to_handle(cmd_buffer), - cmd_buffer->state.framebuffer->vp_state); - - if (cmd_buffer->state.ds_state == NULL) - anv_CmdBindDynamicDepthStencilState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.ds_state); - - if (cmd_buffer->state.cb_state == NULL) - anv_CmdBindDynamicColorBlendState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.cb_state); - ANV_CALL(CmdDraw)(anv_cmd_buffer_to_handle(cmd_buffer), 3, num_instances, 0, 0); } @@ -466,7 +445,9 @@ anv_cmd_buffer_clear_attachments(struct anv_cmd_buffer *cmd_buffer, } } - anv_cmd_buffer_save(cmd_buffer, &saved_state); + anv_cmd_buffer_save(cmd_buffer, &saved_state, + (1 << VK_DYNAMIC_STATE_VIEWPORT)); + cmd_buffer->state.dynamic.viewport.count = 0; struct anv_subpass subpass = { .input_count = 0, @@ -703,20 +684,8 @@ static void meta_prepare_blit(struct anv_cmd_buffer *cmd_buffer, struct anv_saved_state *saved_state) { - struct anv_device *device = cmd_buffer->device; - - anv_cmd_buffer_save(cmd_buffer, saved_state); - - /* We don't need anything here, only set if not already set. */ - if (cmd_buffer->state.rs_state == NULL) - anv_CmdBindDynamicRasterState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.rs_state); - if (cmd_buffer->state.ds_state == NULL) - anv_CmdBindDynamicDepthStencilState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.ds_state); - - anv_CmdBindDynamicColorBlendState(anv_cmd_buffer_to_handle(cmd_buffer), - device->meta_state.shared.cb_state); + anv_cmd_buffer_save(cmd_buffer, saved_state, + (1 << VK_DYNAMIC_STATE_VIEWPORT)); } struct blit_region { @@ -913,8 +882,15 @@ meta_emit_blit(struct anv_cmd_buffer *cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); } - anv_CmdBindDynamicViewportState(anv_cmd_buffer_to_handle(cmd_buffer), - anv_framebuffer_from_handle(fb)->vp_state); + anv_CmdSetViewport(anv_cmd_buffer_to_handle(cmd_buffer), 1, + &(VkViewport) { + .originX = 0.0f, + .originY = 0.0f, + .width = dest_iview->extent.width, + .height = dest_iview->extent.height, + .minDepth = 0.0f, + .maxDepth = 1.0f, + }); anv_CmdBindDescriptorSets(anv_cmd_buffer_to_handle(cmd_buffer), VK_PIPELINE_BIND_POINT_GRAPHICS, @@ -1604,7 +1580,9 @@ void anv_CmdClearColorImage( ANV_FROM_HANDLE(anv_image, image, _image); struct anv_saved_state saved_state; - anv_cmd_buffer_save(cmd_buffer, &saved_state); + anv_cmd_buffer_save(cmd_buffer, &saved_state, + (1 << VK_DYNAMIC_STATE_VIEWPORT)); + cmd_buffer->state.dynamic.viewport.count = 0; for (uint32_t r = 0; r < rangeCount; r++) { for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) { @@ -1769,24 +1747,6 @@ anv_device_init_meta(struct anv_device *device) { anv_device_init_meta_clear_state(device); anv_device_init_meta_blit_state(device); - - ANV_CALL(CreateDynamicRasterState)(anv_device_to_handle(device), - &(VkDynamicRasterStateCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO, - }, - &device->meta_state.shared.rs_state); - - ANV_CALL(CreateDynamicColorBlendState)(anv_device_to_handle(device), - &(VkDynamicColorBlendStateCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO - }, - &device->meta_state.shared.cb_state); - - ANV_CALL(CreateDynamicDepthStencilState)(anv_device_to_handle(device), - &(VkDynamicDepthStencilStateCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO - }, - &device->meta_state.shared.ds_state); } void @@ -1805,12 +1765,4 @@ anv_device_finish_meta(struct anv_device *device) device->meta_state.blit.pipeline_layout); anv_DestroyDescriptorSetLayout(anv_device_to_handle(device), device->meta_state.blit.ds_layout); - - /* Shared */ - anv_DestroyDynamicRasterState(anv_device_to_handle(device), - device->meta_state.shared.rs_state); - anv_DestroyDynamicColorBlendState(anv_device_to_handle(device), - device->meta_state.shared.cb_state); - anv_DestroyDynamicDepthStencilState(anv_device_to_handle(device), - device->meta_state.shared.ds_state); } diff --git a/src/vulkan/anv_private.h b/src/vulkan/anv_private.h index 047c1cf4355..3d47739aae7 100644 --- a/src/vulkan/anv_private.h +++ b/src/vulkan/anv_private.h @@ -450,12 +450,6 @@ struct anv_meta_state { VkPipelineLayout pipeline_layout; VkDescriptorSetLayout ds_layout; } blit; - - struct { - VkDynamicRasterState rs_state; - VkDynamicColorBlendState cb_state; - VkDynamicDepthStencilState ds_state; - } shared; }; struct anv_queue { @@ -680,40 +674,6 @@ struct anv_device_memory { void * map; }; -struct anv_dynamic_vp_state { - struct anv_state sf_clip_vp; - struct anv_state cc_vp; - struct anv_state scissor; -}; - -struct anv_dynamic_rs_state { - struct { - uint32_t sf[GEN7_3DSTATE_SF_length]; - } gen7; - - struct { - uint32_t sf[GEN8_3DSTATE_SF_length]; - uint32_t raster[GEN8_3DSTATE_RASTER_length]; - } gen8; -}; - -struct anv_dynamic_ds_state { - struct { - uint32_t depth_stencil_state[GEN7_DEPTH_STENCIL_STATE_length]; - uint32_t color_calc_state[GEN8_COLOR_CALC_STATE_length]; - } gen7; - - struct { - uint32_t wm_depth_stencil[GEN8_3DSTATE_WM_DEPTH_STENCIL_length]; - uint32_t color_calc_state[GEN8_COLOR_CALC_STATE_length]; - } gen8; -}; - -struct anv_dynamic_cb_state { - uint32_t color_calc_state[GEN8_COLOR_CALC_STATE_length]; - -}; - struct anv_descriptor_slot { int8_t dynamic_slot; uint8_t index; @@ -800,12 +760,18 @@ struct anv_buffer { VkDeviceSize offset; }; -#define ANV_CMD_BUFFER_PIPELINE_DIRTY (1 << 0) -#define ANV_CMD_BUFFER_RS_DIRTY (1 << 2) -#define ANV_CMD_BUFFER_DS_DIRTY (1 << 3) -#define ANV_CMD_BUFFER_CB_DIRTY (1 << 4) -#define ANV_CMD_BUFFER_VP_DIRTY (1 << 5) -#define ANV_CMD_BUFFER_INDEX_BUFFER_DIRTY (1 << 6) +/* The first 9 correspond to 1 << VK_DYNAMIC_STATE_FOO */ +#define ANV_DYNAMIC_VIEWPORT_DIRTY (1 << 0) +#define ANV_DYNAMIC_SCISSOR_DIRTY (1 << 1) +#define ANV_DYNAMIC_LINE_WIDTH_DIRTY (1 << 2) +#define ANV_DYNAMIC_DEPTH_BIAS_DIRTY (1 << 3) +#define ANV_DYNAMIC_BLEND_CONSTANTS_DIRTY (1 << 4) +#define ANV_DYNAMIC_DEPTH_BOUNDS_DIRTY (1 << 5) +#define ANV_DYNAMIC_STENCIL_COMPARE_MASK_DIRTY (1 << 6) +#define ANV_DYNAMIC_STENCIL_WRITE_MASK_DIRTY (1 << 7) +#define ANV_DYNAMIC_STENCIL_REFERENCE_DIRTY (1 << 8) +#define ANV_CMD_BUFFER_PIPELINE_DIRTY (1 << 9) +#define ANV_CMD_BUFFER_INDEX_BUFFER_DIRTY (1 << 10) struct anv_vertex_binding { struct anv_buffer * buffer; @@ -903,14 +869,11 @@ struct anv_cmd_state { struct anv_framebuffer * framebuffer; struct anv_render_pass * pass; struct anv_subpass * subpass; - struct anv_dynamic_rs_state * rs_state; - struct anv_dynamic_ds_state * ds_state; - struct anv_dynamic_vp_state * vp_state; - struct anv_dynamic_cb_state * cb_state; uint32_t state_vf[GEN8_3DSTATE_VF_length]; struct anv_vertex_binding vertex_bindings[MAX_VBS]; struct anv_descriptor_set_binding descriptors[MAX_SETS]; struct anv_push_constants * push_constants[VK_SHADER_STAGE_NUM]; + struct anv_dynamic_state dynamic; struct { struct anv_buffer * index_buffer; @@ -1028,6 +991,9 @@ anv_cmd_buffer_alloc_dynamic_state(struct anv_cmd_buffer *cmd_buffer, VkResult anv_cmd_buffer_new_binding_table_block(struct anv_cmd_buffer *cmd_buffer); +void anv_cmd_buffer_emit_viewport(struct anv_cmd_buffer *cmd_buffer); +void anv_cmd_buffer_emit_scissor(struct anv_cmd_buffer *cmd_buffer); + void gen7_cmd_buffer_emit_state_base_address(struct anv_cmd_buffer *cmd_buffer); void gen8_cmd_buffer_emit_state_base_address(struct anv_cmd_buffer *cmd_buffer); @@ -1369,9 +1335,6 @@ struct anv_framebuffer { uint32_t height; uint32_t layers; - /* Viewport for clears */ - VkDynamicViewportState vp_state; - uint32_t attachment_count; const struct anv_image_view * attachments[0]; }; @@ -1464,10 +1427,6 @@ ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_buffer_view, VkBufferView); ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_descriptor_set, VkDescriptorSet) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_descriptor_set_layout, VkDescriptorSetLayout) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_device_memory, VkDeviceMemory) -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_dynamic_cb_state, VkDynamicColorBlendState) -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_dynamic_ds_state, VkDynamicDepthStencilState) -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_dynamic_rs_state, VkDynamicRasterState) -ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_dynamic_vp_state, VkDynamicViewportState) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_fence, VkFence) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_framebuffer, VkFramebuffer) ANV_DEFINE_NONDISP_HANDLE_CASTS(anv_image, VkImage) diff --git a/src/vulkan/gen7_cmd_buffer.c b/src/vulkan/gen7_cmd_buffer.c index 709e82e78a0..0106aa74aa6 100644 --- a/src/vulkan/gen7_cmd_buffer.c +++ b/src/vulkan/gen7_cmd_buffer.c @@ -256,60 +256,87 @@ gen7_cmd_buffer_flush_state(struct anv_cmd_buffer *cmd_buffer) if (cmd_buffer->state.descriptors_dirty) anv_flush_descriptor_sets(cmd_buffer); - if (cmd_buffer->state.dirty & ANV_CMD_BUFFER_VP_DIRTY) { - struct anv_dynamic_vp_state *vp_state = cmd_buffer->state.vp_state; - anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_SCISSOR_STATE_POINTERS, - .ScissorRectPointer = vp_state->scissor.offset); - anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_VIEWPORT_STATE_POINTERS_CC, - .CCViewportPointer = vp_state->cc_vp.offset); - anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP, - .SFClipViewportPointer = vp_state->sf_clip_vp.offset); + if (cmd_buffer->state.dirty & ANV_DYNAMIC_VIEWPORT_DIRTY) + anv_cmd_buffer_emit_viewport(cmd_buffer); + + if (cmd_buffer->state.dirty & ANV_DYNAMIC_SCISSOR_DIRTY) + anv_cmd_buffer_emit_scissor(cmd_buffer); + + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | + ANV_DYNAMIC_LINE_WIDTH_DIRTY | + ANV_DYNAMIC_DEPTH_BIAS_DIRTY)) { + + bool enable_bias = cmd_buffer->state.dynamic.depth_bias.bias != 0.0f || + cmd_buffer->state.dynamic.depth_bias.slope_scaled != 0.0f; + + uint32_t sf_dw[GEN8_3DSTATE_SF_length]; + struct GEN7_3DSTATE_SF sf = { + GEN7_3DSTATE_SF_header, + .LineWidth = cmd_buffer->state.dynamic.line_width, + .GlobalDepthOffsetEnableSolid = enable_bias, + .GlobalDepthOffsetEnableWireframe = enable_bias, + .GlobalDepthOffsetEnablePoint = enable_bias, + .GlobalDepthOffsetConstant = cmd_buffer->state.dynamic.depth_bias.bias, + .GlobalDepthOffsetScale = cmd_buffer->state.dynamic.depth_bias.slope_scaled, + .GlobalDepthOffsetClamp = cmd_buffer->state.dynamic.depth_bias.clamp + }; + GEN7_3DSTATE_SF_pack(NULL, sf_dw, &sf); + + anv_batch_emit_merge(&cmd_buffer->batch, sf_dw, pipeline->gen7.sf); } - if (cmd_buffer->state.dirty & - (ANV_CMD_BUFFER_PIPELINE_DIRTY | ANV_CMD_BUFFER_RS_DIRTY)) { - anv_batch_emit_merge(&cmd_buffer->batch, - cmd_buffer->state.rs_state->gen7.sf, - pipeline->gen7.sf); - } + if (cmd_buffer->state.dirty & (ANV_DYNAMIC_BLEND_CONSTANTS_DIRTY | + ANV_DYNAMIC_STENCIL_REFERENCE_DIRTY)) { + struct anv_state cc_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, + GEN7_COLOR_CALC_STATE_length, 64); + struct GEN7_COLOR_CALC_STATE cc = { + .BlendConstantColorRed = cmd_buffer->state.dynamic.blend_constants[0], + .BlendConstantColorGreen = cmd_buffer->state.dynamic.blend_constants[1], + .BlendConstantColorBlue = cmd_buffer->state.dynamic.blend_constants[2], + .BlendConstantColorAlpha = cmd_buffer->state.dynamic.blend_constants[3], + .StencilReferenceValue = + cmd_buffer->state.dynamic.stencil_reference.front, + .BackFaceStencilReferenceValue = + cmd_buffer->state.dynamic.stencil_reference.back, + }; + GEN7_COLOR_CALC_STATE_pack(NULL, cc_state.map, &cc); - if (cmd_buffer->state.dirty & - (ANV_CMD_BUFFER_PIPELINE_DIRTY | ANV_CMD_BUFFER_DS_DIRTY)) { - struct anv_state state; - - if (cmd_buffer->state.ds_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - pipeline->gen7.depth_stencil_state, - GEN7_COLOR_CALC_STATE_length, 64); - else - state = anv_cmd_buffer_merge_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen7.depth_stencil_state, - pipeline->gen7.depth_stencil_state, - GEN7_DEPTH_STENCIL_STATE_length, 64); - anv_batch_emit(&cmd_buffer->batch, GEN7_3DSTATE_DEPTH_STENCIL_STATE_POINTERS, - .PointertoDEPTH_STENCIL_STATE = state.offset); + anv_batch_emit(&cmd_buffer->batch, + GEN7_3DSTATE_CC_STATE_POINTERS, + .ColorCalcStatePointer = cc_state.offset); } - if (cmd_buffer->state.dirty & - (ANV_CMD_BUFFER_CB_DIRTY | ANV_CMD_BUFFER_DS_DIRTY)) { - struct anv_state state; - if (cmd_buffer->state.ds_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - cmd_buffer->state.cb_state->color_calc_state, - GEN7_COLOR_CALC_STATE_length, 64); - else if (cmd_buffer->state.cb_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen7.color_calc_state, - GEN7_COLOR_CALC_STATE_length, 64); - else - state = anv_cmd_buffer_merge_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen7.color_calc_state, - cmd_buffer->state.cb_state->color_calc_state, - GEN7_COLOR_CALC_STATE_length, 64); + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | + ANV_DYNAMIC_STENCIL_COMPARE_MASK_DIRTY | + ANV_DYNAMIC_STENCIL_WRITE_MASK_DIRTY)) { + uint32_t depth_stencil_dw[GEN7_DEPTH_STENCIL_STATE_length]; + + struct GEN7_DEPTH_STENCIL_STATE depth_stencil = { + /* Is this what we need to do? */ + .StencilBufferWriteEnable = + cmd_buffer->state.dynamic.stencil_write_mask.front != 0, + + .StencilTestMask = + cmd_buffer->state.dynamic.stencil_compare_mask.front & 0xff, + .StencilWriteMask = + cmd_buffer->state.dynamic.stencil_write_mask.front & 0xff, + + .BackfaceStencilTestMask = + cmd_buffer->state.dynamic.stencil_compare_mask.back & 0xff, + .BackfaceStencilWriteMask = + cmd_buffer->state.dynamic.stencil_write_mask.back & 0xff, + }; + GEN7_DEPTH_STENCIL_STATE_pack(NULL, depth_stencil_dw, &depth_stencil); + + struct anv_state ds_state = + anv_cmd_buffer_merge_dynamic(cmd_buffer, depth_stencil_dw, + pipeline->gen7.depth_stencil_state, + GEN7_DEPTH_STENCIL_STATE_length, 64); anv_batch_emit(&cmd_buffer->batch, - GEN7_3DSTATE_CC_STATE_POINTERS, - .ColorCalcStatePointer = state.offset); + GEN7_3DSTATE_DEPTH_STENCIL_STATE_POINTERS, + .PointertoDEPTH_STENCIL_STATE = ds_state.offset); } if (cmd_buffer->state.gen7.index_buffer && diff --git a/src/vulkan/gen7_state.c b/src/vulkan/gen7_state.c index 2497e39490d..d317fa4ec16 100644 --- a/src/vulkan/gen7_state.c +++ b/src/vulkan/gen7_state.c @@ -192,78 +192,6 @@ VkResult gen7_CreateSampler( return VK_SUCCESS; } -VkResult gen7_CreateDynamicRasterState( - VkDevice _device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_rs_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - bool enable_bias = pCreateInfo->depthBias != 0.0f || - pCreateInfo->slopeScaledDepthBias != 0.0f; - - struct GEN7_3DSTATE_SF sf = { - GEN7_3DSTATE_SF_header, - .LineWidth = pCreateInfo->lineWidth, - .GlobalDepthOffsetEnableSolid = enable_bias, - .GlobalDepthOffsetEnableWireframe = enable_bias, - .GlobalDepthOffsetEnablePoint = enable_bias, - .GlobalDepthOffsetConstant = pCreateInfo->depthBias, - .GlobalDepthOffsetScale = pCreateInfo->slopeScaledDepthBias, - .GlobalDepthOffsetClamp = pCreateInfo->depthBiasClamp - }; - - GEN7_3DSTATE_SF_pack(NULL, state->gen7.sf, &sf); - - *pState = anv_dynamic_rs_state_to_handle(state); - - return VK_SUCCESS; -} - -VkResult gen7_CreateDynamicDepthStencilState( - VkDevice _device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_ds_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - struct GEN7_DEPTH_STENCIL_STATE depth_stencil_state = { - .StencilTestMask = pCreateInfo->stencilReadMask & 0xff, - .StencilWriteMask = pCreateInfo->stencilWriteMask & 0xff, - .BackfaceStencilTestMask = pCreateInfo->stencilReadMask & 0xff, - .BackfaceStencilWriteMask = pCreateInfo->stencilWriteMask & 0xff, - }; - - GEN7_DEPTH_STENCIL_STATE_pack(NULL, state->gen7.depth_stencil_state, - &depth_stencil_state); - - struct GEN7_COLOR_CALC_STATE color_calc_state = { - .StencilReferenceValue = pCreateInfo->stencilFrontRef, - .BackFaceStencilReferenceValue = pCreateInfo->stencilBackRef - }; - - GEN7_COLOR_CALC_STATE_pack(NULL, state->gen7.color_calc_state, &color_calc_state); - - *pState = anv_dynamic_ds_state_to_handle(state); - - return VK_SUCCESS; -} static const uint8_t anv_halign[] = { [4] = HALIGN_4, diff --git a/src/vulkan/gen8_cmd_buffer.c b/src/vulkan/gen8_cmd_buffer.c index 1cd4a8561e6..a1db0170c09 100644 --- a/src/vulkan/gen8_cmd_buffer.c +++ b/src/vulkan/gen8_cmd_buffer.c @@ -121,57 +121,95 @@ gen8_cmd_buffer_flush_state(struct anv_cmd_buffer *cmd_buffer) if (cmd_buffer->state.push_constants_dirty) gen8_cmd_buffer_flush_push_constants(cmd_buffer); - if (cmd_buffer->state.dirty & ANV_CMD_BUFFER_VP_DIRTY) { - struct anv_dynamic_vp_state *vp_state = cmd_buffer->state.vp_state; - anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_SCISSOR_STATE_POINTERS, - .ScissorRectPointer = vp_state->scissor.offset); - anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC, - .CCViewportPointer = vp_state->cc_vp.offset); - anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP, - .SFClipViewportPointer = vp_state->sf_clip_vp.offset); - } + if (cmd_buffer->state.dirty & ANV_DYNAMIC_VIEWPORT_DIRTY) + anv_cmd_buffer_emit_viewport(cmd_buffer); + + if (cmd_buffer->state.dirty & ANV_DYNAMIC_SCISSOR_DIRTY) + anv_cmd_buffer_emit_scissor(cmd_buffer); if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | - ANV_CMD_BUFFER_RS_DIRTY)) { - anv_batch_emit_merge(&cmd_buffer->batch, - cmd_buffer->state.rs_state->gen8.sf, - pipeline->gen8.sf); - anv_batch_emit_merge(&cmd_buffer->batch, - cmd_buffer->state.rs_state->gen8.raster, - pipeline->gen8.raster); + ANV_DYNAMIC_LINE_WIDTH_DIRTY)) { + uint32_t sf_dw[GEN8_3DSTATE_SF_length]; + struct GEN8_3DSTATE_SF sf = { + GEN8_3DSTATE_SF_header, + .LineWidth = cmd_buffer->state.dynamic.line_width, + }; + GEN8_3DSTATE_SF_pack(NULL, sf_dw, &sf); + anv_batch_emit_merge(&cmd_buffer->batch, sf_dw, pipeline->gen8.sf); } - if (cmd_buffer->state.ds_state && - (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | - ANV_CMD_BUFFER_DS_DIRTY))) { - anv_batch_emit_merge(&cmd_buffer->batch, - cmd_buffer->state.ds_state->gen8.wm_depth_stencil, - pipeline->gen8.wm_depth_stencil); + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | + ANV_DYNAMIC_DEPTH_BIAS_DIRTY)) { + bool enable_bias = cmd_buffer->state.dynamic.depth_bias.bias != 0.0f || + cmd_buffer->state.dynamic.depth_bias.slope_scaled != 0.0f; + + uint32_t raster_dw[GEN8_3DSTATE_RASTER_length]; + struct GEN8_3DSTATE_RASTER raster = { + GEN8_3DSTATE_RASTER_header, + .GlobalDepthOffsetEnableSolid = enable_bias, + .GlobalDepthOffsetEnableWireframe = enable_bias, + .GlobalDepthOffsetEnablePoint = enable_bias, + .GlobalDepthOffsetConstant = cmd_buffer->state.dynamic.depth_bias.bias, + .GlobalDepthOffsetScale = cmd_buffer->state.dynamic.depth_bias.slope_scaled, + .GlobalDepthOffsetClamp = cmd_buffer->state.dynamic.depth_bias.clamp + }; + GEN8_3DSTATE_RASTER_pack(NULL, raster_dw, &raster); + anv_batch_emit_merge(&cmd_buffer->batch, raster_dw, + pipeline->gen8.raster); } - if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_CB_DIRTY | - ANV_CMD_BUFFER_DS_DIRTY)) { - struct anv_state state; - if (cmd_buffer->state.ds_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - cmd_buffer->state.cb_state->color_calc_state, - GEN8_COLOR_CALC_STATE_length, 64); - else if (cmd_buffer->state.cb_state == NULL) - state = anv_cmd_buffer_emit_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen8.color_calc_state, - GEN8_COLOR_CALC_STATE_length, 64); - else - state = anv_cmd_buffer_merge_dynamic(cmd_buffer, - cmd_buffer->state.ds_state->gen8.color_calc_state, - cmd_buffer->state.cb_state->color_calc_state, - GEN8_COLOR_CALC_STATE_length, 64); + if (cmd_buffer->state.dirty & (ANV_DYNAMIC_BLEND_CONSTANTS_DIRTY | + ANV_DYNAMIC_STENCIL_REFERENCE_DIRTY)) { + struct anv_state cc_state = + anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, + GEN8_COLOR_CALC_STATE_length, 64); + struct GEN8_COLOR_CALC_STATE cc = { + .BlendConstantColorRed = cmd_buffer->state.dynamic.blend_constants[0], + .BlendConstantColorGreen = cmd_buffer->state.dynamic.blend_constants[1], + .BlendConstantColorBlue = cmd_buffer->state.dynamic.blend_constants[2], + .BlendConstantColorAlpha = cmd_buffer->state.dynamic.blend_constants[3], + .StencilReferenceValue = + cmd_buffer->state.dynamic.stencil_reference.front, + .BackFaceStencilReferenceValue = + cmd_buffer->state.dynamic.stencil_reference.back, + }; + GEN8_COLOR_CALC_STATE_pack(NULL, cc_state.map, &cc); anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_CC_STATE_POINTERS, - .ColorCalcStatePointer = state.offset, + .ColorCalcStatePointer = cc_state.offset, .ColorCalcStatePointerValid = true); } + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | + ANV_DYNAMIC_STENCIL_COMPARE_MASK_DIRTY | + ANV_DYNAMIC_STENCIL_WRITE_MASK_DIRTY)) { + uint32_t wm_depth_stencil_dw[GEN8_3DSTATE_WM_DEPTH_STENCIL_length]; + + struct GEN8_3DSTATE_WM_DEPTH_STENCIL wm_depth_stencil = { + GEN8_3DSTATE_WM_DEPTH_STENCIL_header, + + /* Is this what we need to do? */ + .StencilBufferWriteEnable = + cmd_buffer->state.dynamic.stencil_write_mask.front != 0, + + .StencilTestMask = + cmd_buffer->state.dynamic.stencil_compare_mask.front & 0xff, + .StencilWriteMask = + cmd_buffer->state.dynamic.stencil_write_mask.front & 0xff, + + .BackfaceStencilTestMask = + cmd_buffer->state.dynamic.stencil_compare_mask.back & 0xff, + .BackfaceStencilWriteMask = + cmd_buffer->state.dynamic.stencil_write_mask.back & 0xff, + }; + GEN8_3DSTATE_WM_DEPTH_STENCIL_pack(NULL, wm_depth_stencil_dw, + &wm_depth_stencil); + + anv_batch_emit_merge(&cmd_buffer->batch, wm_depth_stencil_dw, + pipeline->gen8.wm_depth_stencil); + } + if (cmd_buffer->state.dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | ANV_CMD_BUFFER_INDEX_BUFFER_DIRTY)) { anv_batch_emit_merge(&cmd_buffer->batch, diff --git a/src/vulkan/gen8_state.c b/src/vulkan/gen8_state.c index 5095ce060bf..9be3bf46021 100644 --- a/src/vulkan/gen8_state.c +++ b/src/vulkan/gen8_state.c @@ -29,46 +29,6 @@ #include "anv_private.h" -VkResult gen8_CreateDynamicRasterState( - VkDevice _device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_rs_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - struct GEN8_3DSTATE_SF sf = { - GEN8_3DSTATE_SF_header, - .LineWidth = pCreateInfo->lineWidth, - }; - - GEN8_3DSTATE_SF_pack(NULL, state->gen8.sf, &sf); - - bool enable_bias = pCreateInfo->depthBias != 0.0f || - pCreateInfo->slopeScaledDepthBias != 0.0f; - struct GEN8_3DSTATE_RASTER raster = { - .GlobalDepthOffsetEnableSolid = enable_bias, - .GlobalDepthOffsetEnableWireframe = enable_bias, - .GlobalDepthOffsetEnablePoint = enable_bias, - .GlobalDepthOffsetConstant = pCreateInfo->depthBias, - .GlobalDepthOffsetScale = pCreateInfo->slopeScaledDepthBias, - .GlobalDepthOffsetClamp = pCreateInfo->depthBiasClamp - }; - - GEN8_3DSTATE_RASTER_pack(NULL, state->gen8.raster, &raster); - - *pState = anv_dynamic_rs_state_to_handle(state); - - return VK_SUCCESS; -} - void gen8_fill_buffer_surface_state(void *state, const struct anv_format *format, uint32_t offset, uint32_t range) @@ -407,46 +367,3 @@ VkResult gen8_CreateSampler( return VK_SUCCESS; } - -VkResult gen8_CreateDynamicDepthStencilState( - VkDevice _device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_ds_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - struct GEN8_3DSTATE_WM_DEPTH_STENCIL wm_depth_stencil = { - GEN8_3DSTATE_WM_DEPTH_STENCIL_header, - - /* Is this what we need to do? */ - .StencilBufferWriteEnable = pCreateInfo->stencilWriteMask != 0, - - .StencilTestMask = pCreateInfo->stencilReadMask & 0xff, - .StencilWriteMask = pCreateInfo->stencilWriteMask & 0xff, - - .BackfaceStencilTestMask = pCreateInfo->stencilReadMask & 0xff, - .BackfaceStencilWriteMask = pCreateInfo->stencilWriteMask & 0xff, - }; - - GEN8_3DSTATE_WM_DEPTH_STENCIL_pack(NULL, state->gen8.wm_depth_stencil, - &wm_depth_stencil); - - struct GEN8_COLOR_CALC_STATE color_calc_state = { - .StencilReferenceValue = pCreateInfo->stencilFrontRef, - .BackFaceStencilReferenceValue = pCreateInfo->stencilBackRef - }; - - GEN8_COLOR_CALC_STATE_pack(NULL, state->gen8.color_calc_state, &color_calc_state); - - *pState = anv_dynamic_ds_state_to_handle(state); - - return VK_SUCCESS; -}