From 709c17412ad29375589ed6c83fdea1cfd5438a20 Mon Sep 17 00:00:00 2001 From: Cody Northrop Date: Mon, 17 Aug 2015 11:10:49 -0600 Subject: [PATCH] Bug 14323: RasterLine and RasterDepthBias changes --- demos/cube.c | 31 ++++++-- demos/tri.c | 31 ++++++-- icd/nulldrv/nulldrv.c | 73 ++++++++++++++---- icd/nulldrv/nulldrv.h | 6 +- include/vk_debug_report_lunarg.h | 31 ++++---- include/vk_layer.h | 9 ++- include/vulkan.h | 128 +++++++++++++++++++------------- layers/draw_state.cpp | 123 +++++++++++++++++++++++-------- layers/draw_state.h | 19 +++-- layers/layer_common.h | 15 ++-- layers/mem_tracker.cpp | 133 +++++++++++++++++++++++++-------- layers/param_checker.cpp | 155 ++++++++++++++++++++++++++++++++------- loader/gpa_helper.h | 18 +++-- loader/table_ops.h | 27 ++++--- loader/trampoline.c | 39 ++++++++-- vk-layer-generate.py | 5 +- vulkan.py | 33 ++++++--- 17 files changed, 638 insertions(+), 238 deletions(-) diff --git a/demos/cube.c b/demos/cube.c index 662f31c..10c6057 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -365,7 +365,8 @@ struct demo { VkPipeline pipeline; VkDynamicViewportState viewport; - VkDynamicRasterState raster; + VkDynamicRasterLineState raster_line; + VkDynamicRasterDepthBiasState raster_depth_bias; VkDynamicColorBlendState color_blend; VkDynamicDepthStencilState depth_stencil; @@ -540,7 +541,8 @@ static void demo_draw_build_cmd(struct demo *demo, VkCmdBuffer cmd_buf) 0, 1, &demo->desc_set, 0, NULL); vkCmdBindDynamicViewportState(cmd_buf, demo->viewport); - vkCmdBindDynamicRasterState(cmd_buf, demo->raster); + vkCmdBindDynamicRasterLineState(cmd_buf, demo->raster_line); + vkCmdBindDynamicRasterDepthBiasState(cmd_buf, demo->raster_depth_bias); vkCmdBindDynamicColorBlendState(cmd_buf, demo->color_blend); vkCmdBindDynamicDepthStencilState(cmd_buf, demo->depth_stencil); @@ -1587,6 +1589,8 @@ static void demo_prepare_pipeline(struct demo *demo) rs.cullMode = VK_CULL_MODE_BACK; rs.frontFace = VK_FRONT_FACE_CCW; rs.depthClipEnable = VK_TRUE; + rs.rasterizerDiscardEnable = VK_FALSE; + rs.depthBiasEnable = VK_FALSE; memset(&cb, 0, sizeof(cb)); cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; @@ -1662,7 +1666,8 @@ static void demo_prepare_pipeline(struct demo *demo) static void demo_prepare_dynamic_states(struct demo *demo) { VkDynamicViewportStateCreateInfo viewport_create; - VkDynamicRasterStateCreateInfo raster; + VkDynamicRasterLineStateCreateInfo raster_line; + VkDynamicRasterDepthBiasStateCreateInfo raster_depth_bias; VkDynamicColorBlendStateCreateInfo color_blend; VkDynamicDepthStencilStateCreateInfo depth_stencil; VkResult U_ASSERT_ONLY err; @@ -1685,9 +1690,15 @@ static void demo_prepare_dynamic_states(struct demo *demo) scissor.offset.y = 0; viewport_create.pScissors = &scissor; - memset(&raster, 0, sizeof(raster)); - raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO; - raster.lineWidth = 1.0; + memset(&raster_line, 0, sizeof(raster_line)); + raster_line.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO; + raster_line.lineWidth = 1.0; + + memset(&raster_depth_bias, 0, sizeof(raster_depth_bias)); + raster_depth_bias.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO; + raster_depth_bias.depthBias = 0.0f; + raster_depth_bias.depthBiasClamp = 0.0f; + raster_depth_bias.slopeScaledDepthBias = 0.0f; memset(&color_blend, 0, sizeof(color_blend)); color_blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO; @@ -1708,7 +1719,10 @@ static void demo_prepare_dynamic_states(struct demo *demo) err = vkCreateDynamicViewportState(demo->device, &viewport_create, &demo->viewport); assert(!err); - err = vkCreateDynamicRasterState(demo->device, &raster, &demo->raster); + err = vkCreateDynamicRasterLineState(demo->device, &raster_line, &demo->raster_line); + assert(!err); + + err = vkCreateDynamicRasterDepthBiasState(demo->device, &raster_depth_bias, &demo->raster_depth_bias); assert(!err); err = vkCreateDynamicColorBlendState(demo->device, @@ -1879,7 +1893,8 @@ static void demo_cleanup(struct demo *demo) vkDestroyDescriptorPool(demo->device, demo->desc_pool); vkDestroyDynamicViewportState(demo->device, demo->viewport); - vkDestroyDynamicRasterState(demo->device, demo->raster); + vkDestroyDynamicRasterLineState(demo->device, demo->raster_line); + vkDestroyDynamicRasterDepthBiasState(demo->device, demo->raster_depth_bias); vkDestroyDynamicColorBlendState(demo->device, demo->color_blend); vkDestroyDynamicDepthStencilState(demo->device, demo->depth_stencil); diff --git a/demos/tri.c b/demos/tri.c index 950da4b..d0ff470 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -217,7 +217,8 @@ struct demo { VkPipeline pipeline; VkDynamicViewportState viewport; - VkDynamicRasterState raster; + VkDynamicRasterLineState raster_line; + VkDynamicRasterDepthBiasState raster_depth_bias; VkDynamicColorBlendState color_blend; VkDynamicDepthStencilState depth_stencil; @@ -382,7 +383,8 @@ static void demo_draw_build_cmd(struct demo *demo) 0, 1, & demo->desc_set, 0, NULL); vkCmdBindDynamicViewportState(demo->draw_cmd, demo->viewport); - vkCmdBindDynamicRasterState(demo->draw_cmd, demo->raster); + vkCmdBindDynamicRasterLineState(demo->draw_cmd, demo->raster_line); + vkCmdBindDynamicRasterDepthBiasState(demo->draw_cmd, demo->raster_depth_bias); vkCmdBindDynamicColorBlendState(demo->draw_cmd, demo->color_blend); vkCmdBindDynamicDepthStencilState(demo->draw_cmd, demo->depth_stencil); @@ -1224,6 +1226,8 @@ static void demo_prepare_pipeline(struct demo *demo) rs.cullMode = VK_CULL_MODE_BACK; rs.frontFace = VK_FRONT_FACE_CW; rs.depthClipEnable = VK_TRUE; + rs.rasterizerDiscardEnable = VK_FALSE; + rs.depthBiasEnable = VK_FALSE; memset(&cb, 0, sizeof(cb)); cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; @@ -1299,7 +1303,8 @@ static void demo_prepare_pipeline(struct demo *demo) static void demo_prepare_dynamic_states(struct demo *demo) { VkDynamicViewportStateCreateInfo viewport_create; - VkDynamicRasterStateCreateInfo raster; + VkDynamicRasterLineStateCreateInfo raster_line; + VkDynamicRasterDepthBiasStateCreateInfo raster_depth_bias; VkDynamicColorBlendStateCreateInfo color_blend; VkDynamicDepthStencilStateCreateInfo depth_stencil; VkResult U_ASSERT_ONLY err; @@ -1322,9 +1327,15 @@ static void demo_prepare_dynamic_states(struct demo *demo) scissor.offset.y = 0; viewport_create.pScissors = &scissor; - memset(&raster, 0, sizeof(raster)); - raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO; - raster.lineWidth = 1.0; + memset(&raster_line, 0, sizeof(raster_line)); + raster_line.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO; + raster_line.lineWidth = 1.0; + + memset(&raster_depth_bias, 0, sizeof(raster_depth_bias)); + raster_depth_bias.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO; + raster_depth_bias.depthBias = 0.0f; + raster_depth_bias.depthBiasClamp = 0.0f; + raster_depth_bias.slopeScaledDepthBias = 0.0f; memset(&color_blend, 0, sizeof(color_blend)); color_blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO; @@ -1345,7 +1356,10 @@ static void demo_prepare_dynamic_states(struct demo *demo) err = vkCreateDynamicViewportState(demo->device, &viewport_create, &demo->viewport); assert(!err); - err = vkCreateDynamicRasterState(demo->device, &raster, &demo->raster); + err = vkCreateDynamicRasterLineState(demo->device, &raster_line, &demo->raster_line); + assert(!err); + + err = vkCreateDynamicRasterDepthBiasState(demo->device, &raster_depth_bias, &demo->raster_depth_bias); assert(!err); err = vkCreateDynamicColorBlendState(demo->device, @@ -2099,7 +2113,8 @@ static void demo_cleanup(struct demo *demo) vkDestroyCommandPool(demo->device, demo->cmd_pool); vkDestroyDynamicViewportState(demo->device, demo->viewport); - vkDestroyDynamicRasterState(demo->device, demo->raster); + vkDestroyDynamicRasterLineState(demo->device, demo->raster_line); + vkDestroyDynamicRasterDepthBiasState(demo->device, demo->raster_depth_bias); vkDestroyDynamicColorBlendState(demo->device, demo->color_blend); vkDestroyDynamicDepthStencilState(demo->device, demo->depth_stencil); diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c index da35982..37a9324 100644 --- a/icd/nulldrv/nulldrv.c +++ b/icd/nulldrv/nulldrv.c @@ -518,14 +518,30 @@ static VkResult nulldrv_viewport_state_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VkResult nulldrv_raster_state_create(struct nulldrv_dev *dev, - const VkDynamicRasterStateCreateInfo *info, - struct nulldrv_dynamic_rs **state_ret) +static VkResult nulldrv_raster_line_state_create(struct nulldrv_dev *dev, + const VkDynamicRasterLineStateCreateInfo *info, + struct nulldrv_dynamic_rs_line **state_ret) { - struct nulldrv_dynamic_rs *state; + struct nulldrv_dynamic_rs_line *state; - state = (struct nulldrv_dynamic_rs *) nulldrv_base_create(dev, - sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE); + state = (struct nulldrv_dynamic_rs_line *) nulldrv_base_create(dev, + sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE); + if (!state) + return VK_ERROR_OUT_OF_HOST_MEMORY; + + *state_ret = state; + + return VK_SUCCESS; +} + +static VkResult nulldrv_raster_depth_bias_state_create(struct nulldrv_dev *dev, + const VkDynamicRasterDepthBiasStateCreateInfo *info, + struct nulldrv_dynamic_rs_depth_bias **state_ret) +{ + struct nulldrv_dynamic_rs_depth_bias *state; + + state = (struct nulldrv_dynamic_rs_depth_bias *) nulldrv_base_create(dev, + sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE); if (!state) return VK_ERROR_OUT_OF_HOST_MEMORY; @@ -1178,9 +1194,16 @@ ICD_EXPORT void VKAPI vkCmdBindDynamicViewportState( NULLDRV_LOG_FUNC; } -ICD_EXPORT void VKAPI vkCmdBindDynamicRasterState( +ICD_EXPORT void VKAPI vkCmdBindDynamicRasterLineState( VkCmdBuffer cmdBuffer, - VkDynamicRasterState state) + VkDynamicRasterLineState state) +{ + NULLDRV_LOG_FUNC; +} + +ICD_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState( + VkCmdBuffer cmdBuffer, + VkDynamicRasterDepthBiasState state) { NULLDRV_LOG_FUNC; } @@ -2069,21 +2092,41 @@ ICD_EXPORT VkResult VKAPI vkDestroyDynamicViewportState( return VK_SUCCESS; } -ICD_EXPORT VkResult VKAPI vkCreateDynamicRasterState( +ICD_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState( VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState) + const VkDynamicRasterLineStateCreateInfo* pCreateInfo, + VkDynamicRasterLineState* pState) +{ + NULLDRV_LOG_FUNC; + struct nulldrv_dev *dev = nulldrv_dev(device); + + return nulldrv_raster_line_state_create(dev, pCreateInfo, + (struct nulldrv_dynamic_rs_line **) pState); +} + +ICD_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState( + VkDevice device, + const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, + VkDynamicRasterDepthBiasState* pState) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); - return nulldrv_raster_state_create(dev, pCreateInfo, - (struct nulldrv_dynamic_rs **) pState); + return nulldrv_raster_depth_bias_state_create(dev, pCreateInfo, + (struct nulldrv_dynamic_rs_depth_bias **) pState); +} + +ICD_EXPORT VkResult VKAPI vkDestroyDynamicRasterLinesState( + VkDevice device, + VkDynamicRasterLineState dynamicRasterLineState) +{ + NULLDRV_LOG_FUNC; + return VK_SUCCESS; } -ICD_EXPORT VkResult VKAPI vkDestroyDynamicRasterState( +ICD_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState( VkDevice device, - VkDynamicRasterState dynamicRasterState) + VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) { NULLDRV_LOG_FUNC; return VK_SUCCESS; diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h index 9784d5c..191db68 100644 --- a/icd/nulldrv/nulldrv.h +++ b/icd/nulldrv/nulldrv.h @@ -148,7 +148,11 @@ struct nulldrv_dynamic_vp { struct nulldrv_obj obj; }; -struct nulldrv_dynamic_rs { +struct nulldrv_dynamic_rs_line { + struct nulldrv_obj obj; +}; + +struct nulldrv_dynamic_rs_depth_bias { struct nulldrv_obj obj; }; diff --git a/include/vk_debug_report_lunarg.h b/include/vk_debug_report_lunarg.h index 4e1569c..bafdc87 100644 --- a/include/vk_debug_report_lunarg.h +++ b/include/vk_debug_report_lunarg.h @@ -67,18 +67,19 @@ typedef enum { VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 18, VK_OBJECT_TYPE_DESCRIPTOR_POOL = 19, VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE = 20, - VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE = 21, - VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE = 22, - VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE = 23, - VK_OBJECT_TYPE_FENCE = 24, - VK_OBJECT_TYPE_SEMAPHORE = 25, - VK_OBJECT_TYPE_EVENT = 26, - VK_OBJECT_TYPE_QUERY_POOL = 27, - VK_OBJECT_TYPE_FRAMEBUFFER = 28, - VK_OBJECT_TYPE_RENDER_PASS = 29, - VK_OBJECT_TYPE_PIPELINE_CACHE = 30, - VK_OBJECT_TYPE_SWAP_CHAIN_WSI = 31, - VK_OBJECT_TYPE_CMD_POOL = 32, + VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE = 21, + VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE = 22, + VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE = 23, + VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE = 24, + VK_OBJECT_TYPE_FENCE = 25, + VK_OBJECT_TYPE_SEMAPHORE = 26, + VK_OBJECT_TYPE_EVENT = 27, + VK_OBJECT_TYPE_QUERY_POOL = 28, + VK_OBJECT_TYPE_FRAMEBUFFER = 29, + VK_OBJECT_TYPE_RENDER_PASS = 30, + VK_OBJECT_TYPE_PIPELINE_CACHE = 31, + VK_OBJECT_TYPE_SWAP_CHAIN_WSI = 32, + VK_OBJECT_TYPE_CMD_POOL = 33, VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE, VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_CMD_POOL, VK_OBJECT_TYPE_NUM = (VK_OBJECT_TYPE_CMD_POOL - VK_OBJECT_TYPE_INSTANCE + 1), @@ -113,8 +114,10 @@ static inline const char* string_VkDbgObjectType(VkDbgObjectType input_value) return "VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE"; case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE: return "VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE"; - case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE: - return "VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE"; + case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE"; + case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE"; case VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE: return "VK_OBJECT_TYPE_DYNAMIC_VIEPORT_STATE"; case VK_OBJECT_TYPE_EVENT: diff --git a/include/vk_layer.h b/include/vk_layer.h index afc103e..3c3cbad 100644 --- a/include/vk_layer.h +++ b/include/vk_layer.h @@ -104,8 +104,10 @@ typedef struct VkLayerDispatchTable_ PFN_vkUpdateDescriptorSets UpdateDescriptorSets; PFN_vkCreateDynamicViewportState CreateDynamicViewportState; PFN_vkDestroyDynamicViewportState DestroyDynamicViewportState; - PFN_vkCreateDynamicRasterState CreateDynamicRasterState; - PFN_vkDestroyDynamicRasterState DestroyDynamicRasterState; + PFN_vkCreateDynamicRasterLineState CreateDynamicRasterLineState; + PFN_vkDestroyDynamicRasterLineState DestroyDynamicRasterLineState; + PFN_vkCreateDynamicRasterDepthBiasState CreateDynamicRasterDepthBiasState; + PFN_vkDestroyDynamicRasterDepthBiasState DestroyDynamicRasterDepthBiasState; PFN_vkCreateDynamicColorBlendState CreateDynamicColorBlendState; PFN_vkDestroyDynamicColorBlendState DestroyDynamicColorBlendState; PFN_vkCreateDynamicDepthStencilState CreateDynamicDepthStencilState; @@ -125,7 +127,8 @@ typedef struct VkLayerDispatchTable_ PFN_vkResetCommandBuffer ResetCommandBuffer; PFN_vkCmdBindPipeline CmdBindPipeline; PFN_vkCmdBindDynamicViewportState CmdBindDynamicViewportState; - PFN_vkCmdBindDynamicRasterState CmdBindDynamicRasterState; + PFN_vkCmdBindDynamicRasterLineState CmdBindDynamicRasterLineState; + PFN_vkCmdBindDynamicRasterDepthBiasState CmdBindDynamicRasterDepthBiasState; PFN_vkCmdBindDynamicColorBlendState CmdBindDynamicColorBlendState; PFN_vkCmdBindDynamicDepthStencilState CmdBindDynamicDepthStencilState; PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets; diff --git a/include/vulkan.h b/include/vulkan.h index 067546b..0a802b0 100644 --- a/include/vulkan.h +++ b/include/vulkan.h @@ -119,7 +119,8 @@ 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(VkDynamicRasterLineState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterDepthBiasState) VK_DEFINE_NONDISP_HANDLE(VkDynamicColorBlendState) VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthStencilState) VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) @@ -199,45 +200,46 @@ typedef enum { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9, VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 35, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 36, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 37, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 39, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 40, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 41, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 42, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 43, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 44, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 45, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 46, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 47, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 48, - VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 49, + VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 34, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 35, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 36, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 37, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 38, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 40, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 41, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 42, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 43, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 44, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 45, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 46, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 47, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 48, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 49, + VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 50, VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO, VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), @@ -1640,6 +1642,7 @@ typedef struct { VkFillMode fillMode; VkCullMode cullMode; VkFrontFace frontFace; + VkBool32 depthBiasEnable; } VkPipelineRasterStateCreateInfo; typedef struct { @@ -1848,11 +1851,16 @@ typedef struct { typedef struct { VkStructureType sType; const void* pNext; + float lineWidth; +} VkDynamicRasterLineStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; float depthBias; float depthBiasClamp; float slopeScaledDepthBias; - float lineWidth; -} VkDynamicRasterStateCreateInfo; +} VkDynamicRasterDepthBiasStateCreateInfo; typedef struct { VkStructureType sType; @@ -2179,8 +2187,10 @@ typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptor 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 VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState); -typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterLineState)(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterLineState)(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterDepthBiasState)(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterDepthBiasState)(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState); typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState); typedef VkResult (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState); typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState); @@ -2200,7 +2210,8 @@ 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_vkCmdBindDynamicRasterLineState)(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState dynamicRasterLineState); +typedef void (VKAPI *PFN_vkCmdBindDynamicRasterDepthBiasState)(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState); typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState); typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState); 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); @@ -2696,14 +2707,23 @@ VkResult VKAPI vkDestroyDynamicViewportState( VkDevice device, VkDynamicViewportState dynamicViewportState); -VkResult VKAPI vkCreateDynamicRasterState( +VkResult VKAPI vkCreateDynamicRasterLineState( + VkDevice device, + const VkDynamicRasterLineStateCreateInfo* pCreateInfo, + VkDynamicRasterLineState* pState); + +VkResult VKAPI vkDestroyDynamicRasterLineState( + VkDevice device, + VkDynamicRasterLineState dynamicRasterLineState); + +VkResult VKAPI vkCreateDynamicRasterDepthBiasState( VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState); + const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, + VkDynamicRasterDepthBiasState* pState); -VkResult VKAPI vkDestroyDynamicRasterState( +VkResult VKAPI vkDestroyDynamicRasterDepthBiasState( VkDevice device, - VkDynamicRasterState dynamicRasterState); + VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState); VkResult VKAPI vkCreateDynamicColorBlendState( VkDevice device, @@ -2789,9 +2809,13 @@ void VKAPI vkCmdBindDynamicViewportState( VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState); -void VKAPI vkCmdBindDynamicRasterState( +void VKAPI vkCmdBindDynamicRasterLineState( + VkCmdBuffer cmdBuffer, + VkDynamicRasterLineState dynamicRasterLineState); + +void VKAPI vkCmdBindDynamicRasterDepthBiasState( VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState); + VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState); void VKAPI vkCmdBindDynamicColorBlendState( VkCmdBuffer cmdBuffer, diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index a0b867a..c465768 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -65,7 +65,8 @@ unordered_map imageMap; unordered_map viewMap; unordered_map bufferMap; unordered_map dynamicVpStateMap; -unordered_map dynamicRsStateMap; +unordered_map dynamicRasterLineStateMap; +unordered_map dynamicRasterDepthBiasStateMap; unordered_map dynamicCbStateMap; unordered_map dynamicDsStateMap; unordered_map pipelineMap; @@ -140,8 +141,10 @@ static string cmdTypeToString(CMD_TYPE cmd) return "CMD_BINDPIPELINEDELTA"; case CMD_BINDDYNAMICVIEWPORTSTATE: return "CMD_BINDDYNAMICVIEWPORTSTATE"; - case CMD_BINDDYNAMICRASTERSTATE: - return "CMD_BINDDYNAMICRASTERSTATE"; + case CMD_BINDDYNAMICRASTERLINESTATE: + return "CMD_BINDDYNAMICRASTERLINESTATE"; + case CMD_BINDDYNAMICRASTERDEPTHBIASSTATE: + return "CMD_BINDDYNAMICRASTERDEPTHBIASSTATE"; case CMD_BINDDYNAMICCOLORBLENDSTATE: return "CMD_BINDDYNAMICCOLORBLENDSTATE"; case CMD_BINDDYNAMICDEPTHSTENCILSTATE: @@ -257,7 +260,8 @@ static void deleteDynamicState() delete[] (*ii).second.pViewports; } dynamicVpStateMap.clear(); - dynamicRsStateMap.clear(); + dynamicRasterLineStateMap.clear(); + dynamicRasterDepthBiasStateMap.clear(); dynamicCbStateMap.clear(); dynamicDsStateMap.clear(); } @@ -358,8 +362,10 @@ static void* getDynamicStateCreateInfo(const uint64_t handle, const DYNAMIC_STAT switch (type) { case VK_STATE_BIND_POINT_VIEWPORT: return (void*)&dynamicVpStateMap[handle]; - case VK_STATE_BIND_POINT_RASTER: - return (void*)&dynamicRsStateMap[handle]; + case VK_STATE_BIND_POINT_RASTER_LINE: + return (void*)&dynamicRasterLineStateMap[handle]; + case VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS: + return (void*)&dynamicRasterDepthBiasStateMap[handle]; case VK_STATE_BIND_POINT_COLOR_BLEND: return (void*)&dynamicCbStateMap[handle]; case VK_STATE_BIND_POINT_DEPTH_STENCIL: @@ -409,7 +415,8 @@ static PIPELINE_NODE* getPipeline(VkPipeline pipeline) static VkBool32 validate_draw_state_flags(GLOBAL_CB_NODE* pCB, VkBool32 indexedDraw) { VkBool32 result; result = validate_status(pCB, CBSTATUS_NONE, CBSTATUS_VIEWPORT_BOUND, CBSTATUS_VIEWPORT_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_VIEWPORT_NOT_BOUND, "Viewport object not bound to this command buffer"); - result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_BOUND, CBSTATUS_RASTER_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_NOT_BOUND, "Raster object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_LINE_BOUND, CBSTATUS_RASTER_LINE_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_LINE_NOT_BOUND, "Raster line object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_RASTER_DEPTH_BIAS_BOUND, CBSTATUS_RASTER_DEPTH_BIAS_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_RASTER_DEPTH_BIAS_NOT_BOUND, "Raster depth bias object not bound to this command buffer"); result &= validate_status(pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_COLOR_BLEND_BOUND, CBSTATUS_COLOR_BLEND_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_COLOR_BLEND_NOT_BOUND, "Color-blend object not bound to this command buffer"); result &= validate_status(pCB, CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE, CBSTATUS_DEPTH_STENCIL_BOUND, CBSTATUS_DEPTH_STENCIL_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_STENCIL_NOT_BOUND, "Depth-stencil object not bound to this command buffer"); if (indexedDraw) @@ -1135,8 +1142,10 @@ static void set_cb_pso_status(GLOBAL_CB_NODE* pCB, const PIPELINE_NODE* pPipe) static void set_cb_dyn_status(GLOBAL_CB_NODE* pNode, DYNAMIC_STATE_BIND_POINT stateBindPoint) { if (stateBindPoint == VK_STATE_BIND_POINT_VIEWPORT) { pNode->status |= CBSTATUS_VIEWPORT_BOUND; - } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER) { - pNode->status |= CBSTATUS_RASTER_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER_LINE) { + pNode->status |= CBSTATUS_RASTER_LINE_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS) { + pNode->status |= CBSTATUS_RASTER_DEPTH_BIAS_BOUND; } else if (stateBindPoint == VK_STATE_BIND_POINT_COLOR_BLEND) { pNode->status |= CBSTATUS_COLOR_BLEND_BOUND; } else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH_STENCIL) { @@ -1605,9 +1614,16 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, Vk return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterState(device, dynamicRasterState); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState); + // TODO : Clean up any internal data structures using this obj. + return result; +} + +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +{ + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState); // TODO : Clean up any internal data structures using this obj. return result; } @@ -1951,12 +1967,22 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, con return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState) +{ + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER_LINE); + loader_platform_thread_lock_mutex(&globalLock); + dynamicRasterLineStateMap[pState->handle] = *pCreateInfo; + loader_platform_thread_unlock_mutex(&globalLock); + return result; +} + +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState); - //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS); loader_platform_thread_lock_mutex(&globalLock); - dynamicRsStateMap[pState->handle] = *pCreateInfo; + dynamicRasterDepthBiasStateMap[pState->handle] = *pCreateInfo; loader_platform_thread_unlock_mutex(&globalLock); return result; } @@ -2125,30 +2151,57 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, } } } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState dynamicRasterLineState) +{ + GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); + if (pCB) { + if (pCB->state == CB_UPDATE_ACTIVE) { + updateCBTracking(cmdBuffer); + addCmd(pCB, CMD_BINDDYNAMICRASTERLINESTATE); + if (!pCB->activeRenderPass) { + log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS", + "Incorrect call to vkCmdBindDynamicRasterLineState() without an active RenderPass."); + } + loader_platform_thread_lock_mutex(&globalLock); + pCB->status |= CBSTATUS_RASTER_LINE_BOUND; + if (dynamicRasterLineStateMap.find(dynamicRasterLineState.handle) == dynamicRasterLineStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, dynamicRasterLineState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicRasterLineState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterLineState.handle); + } else { + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle; + } + loader_platform_thread_unlock_mutex(&globalLock); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState); + } else { + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterLineState()"); + } + } +} +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { if (pCB->state == CB_UPDATE_ACTIVE) { updateCBTracking(cmdBuffer); - addCmd(pCB, CMD_BINDDYNAMICRASTERSTATE); + addCmd(pCB, CMD_BINDDYNAMICRASTERDEPTHBIASSTATE); if (!pCB->activeRenderPass) { log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS", - "Incorrect call to vkCmdBindDynamicRasterState() without an active RenderPass."); + "Incorrect call to vkCmdBindDynamicRasterDepthBiasState() without an active RenderPass."); } loader_platform_thread_lock_mutex(&globalLock); - pCB->status |= CBSTATUS_RASTER_BOUND; - if (dynamicRsStateMap.find(dynamicRasterState.handle) == dynamicRsStateMap.end()) { - log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, dynamicRasterState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", - "Unable to find VkDynamicRasterState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterState.handle); + pCB->status |= CBSTATUS_RASTER_DEPTH_BIAS_BOUND; + if (dynamicRasterDepthBiasStateMap.find(dynamicRasterDepthBiasState.handle) == dynamicRasterDepthBiasStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, dynamicRasterDepthBiasState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicRasterDepthBiasState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterDepthBiasState.handle); } else { - pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle; - g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle; + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle; } loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState); } else { - report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterState()"); + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterDepthBiasState()"); } } } @@ -3061,8 +3114,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const return (PFN_vkVoidFunction) vkDestroyDescriptorPool; if (!strcmp(funcName, "vkDestroyDynamicViewportState")) return (PFN_vkVoidFunction) vkDestroyDynamicViewportState; - if (!strcmp(funcName, "vkDestroyDynamicRasterState")) - return (PFN_vkVoidFunction) vkDestroyDynamicRasterState; + if (!strcmp(funcName, "vkDestroyDynamicRasterLineState")) + return (PFN_vkVoidFunction) vkDestroyDynamicRasterLineState; + if (!strcmp(funcName, "vkDestroyDynamicRasterDepthBiasState")) + return (PFN_vkVoidFunction) vkDestroyDynamicRasterDepthBiasState; if (!strcmp(funcName, "vkDestroyDynamicColorBlendState")) return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState; if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState")) @@ -3107,8 +3162,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const return (PFN_vkVoidFunction) vkUpdateDescriptorSets; if (!strcmp(funcName, "vkCreateDynamicViewportState")) return (PFN_vkVoidFunction) vkCreateDynamicViewportState; - if (!strcmp(funcName, "vkCreateDynamicRasterState")) - return (PFN_vkVoidFunction) vkCreateDynamicRasterState; + if (!strcmp(funcName, "vkCreateDynamicRasterLineState")) + return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState; + if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState")) + return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState; if (!strcmp(funcName, "vkCreateDynamicColorBlendState")) return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState; if (!strcmp(funcName, "vkCreateDynamicDepthStencilState")) @@ -3125,8 +3182,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const return (PFN_vkVoidFunction) vkCmdBindPipeline; if (!strcmp(funcName, "vkCmdBindDynamicViewportState")) return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState; - if (!strcmp(funcName, "vkCmdBindDynamicRasterState")) - return (PFN_vkVoidFunction) vkCmdBindDynamicRasterState; + if (!strcmp(funcName, "vkCmdBindDynamicRasterLineState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicRasterLineState; + if (!strcmp(funcName, "vkCmdBindDynamicRasterDepthBiasState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicRasterDepthBiasState; if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState")) return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState; if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState")) diff --git a/layers/draw_state.h b/layers/draw_state.h index ebc60f7..4c7c355 100644 --- a/layers/draw_state.h +++ b/layers/draw_state.h @@ -52,7 +52,8 @@ typedef enum _DRAW_STATE_ERROR DRAWSTATE_NO_BEGIN_CMD_BUFFER, // Binding cmds or calling End on CB that never had vkBeginCommandBuffer() called on it DRAWSTATE_CMD_BUFFER_SINGLE_SUBMIT_VIOLATION, // Cmd Buffer created with VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT flag is submitted multiple times DRAWSTATE_VIEWPORT_NOT_BOUND, // Draw submitted with no viewport state object bound - DRAWSTATE_RASTER_NOT_BOUND, // Draw submitted with no raster state object bound + DRAWSTATE_RASTER_LINE_NOT_BOUND, // Draw submitted with no raster line state object bound + DRAWSTATE_RASTER_DEPTH_BIAS_NOT_BOUND, // Draw submitted with no raster depth bias state object bound DRAWSTATE_COLOR_BLEND_NOT_BOUND, // Draw submitted with no color blend state object bound when color write enabled DRAWSTATE_DEPTH_STENCIL_NOT_BOUND, // Draw submitted with no depth-stencil state object bound when depth write enabled DRAWSTATE_INDEX_BUFFER_NOT_BOUND, // Draw submitted with no depth-stencil state object bound when depth write enabled @@ -164,7 +165,8 @@ typedef enum _CMD_TYPE CMD_BINDPIPELINE, CMD_BINDPIPELINEDELTA, CMD_BINDDYNAMICVIEWPORTSTATE, - CMD_BINDDYNAMICRASTERSTATE, + CMD_BINDDYNAMICRASTERLINESTATE, + CMD_BINDDYNAMICRASTERDEPTHBIASSTATE, CMD_BINDDYNAMICCOLORBLENDSTATE, CMD_BINDDYNAMICDEPTHSTENCILSTATE, CMD_BINDDESCRIPTORSETS, @@ -225,12 +227,13 @@ typedef enum _CBStatusFlagBits { CBSTATUS_NONE = 0x00000000, // No status is set CBSTATUS_VIEWPORT_BOUND = 0x00000001, // Viewport state object has been bound - CBSTATUS_RASTER_BOUND = 0x00000002, // Raster state object has been bound - CBSTATUS_COLOR_BLEND_WRITE_ENABLE = 0x00000004, // PSO w/ CB Enable set has been bound - CBSTATUS_COLOR_BLEND_BOUND = 0x00000008, // CB state object has been bound - CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE = 0x00000010, // PSO w/ DS Enable set has been bound - CBSTATUS_DEPTH_STENCIL_BOUND = 0x00000020, // DS state object has been bound - CBSTATUS_INDEX_BUFFER_BOUND = 0x00000040, // Index buffer has been bound + CBSTATUS_RASTER_LINE_BOUND = 0x00000002, // Raster state object has been bound + CBSTATUS_RASTER_DEPTH_BIAS_BOUND = 0x00000004, // Raster state object has been bound + CBSTATUS_COLOR_BLEND_WRITE_ENABLE = 0x00000008, // PSO w/ CB Enable set has been bound + CBSTATUS_COLOR_BLEND_BOUND = 0x00000010, // CB state object has been bound + CBSTATUS_DEPTH_STENCIL_WRITE_ENABLE = 0x00000020, // PSO w/ DS Enable set has been bound + CBSTATUS_DEPTH_STENCIL_BOUND = 0x00000040, // DS state object has been bound + CBSTATUS_INDEX_BUFFER_BOUND = 0x00000080, // Index buffer has been bound } CBStatusFlagBits; // Cmd Buffer Wrapper Struct diff --git a/layers/layer_common.h b/layers/layer_common.h index 5bfb4f7..4cb2ae1 100644 --- a/layers/layer_common.h +++ b/layers/layer_common.h @@ -26,7 +26,8 @@ typedef enum _DYNAMIC_STATE_BIND_POINT { VK_STATE_BIND_POINT_VIEWPORT, - VK_STATE_BIND_POINT_RASTER, + VK_STATE_BIND_POINT_RASTER_LINE, + VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS, VK_STATE_BIND_POINT_COLOR_BLEND, VK_STATE_BIND_POINT_DEPTH_STENCIL, VK_NUM_STATE_BIND_POINT // Used for array sizing @@ -38,8 +39,10 @@ static string string_DYNAMIC_STATE_BIND_POINT(DYNAMIC_STATE_BIND_POINT sbp) { case VK_STATE_BIND_POINT_VIEWPORT: return "VIEWPORT"; - case VK_STATE_BIND_POINT_RASTER: - return "RASTER"; + case VK_STATE_BIND_POINT_RASTER_LINE: + return "RASTER_LINE"; + case VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS: + return "RASTER_DEPTH_BIAS"; case VK_STATE_BIND_POINT_COLOR_BLEND: return "COLOR_BLEND"; case VK_STATE_BIND_POINT_DEPTH_STENCIL: @@ -55,8 +58,10 @@ static VkDbgObjectType dynamicStateBindPointToObjType(DYNAMIC_STATE_BIND_POINT s { case VK_STATE_BIND_POINT_VIEWPORT: return VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE; - case VK_STATE_BIND_POINT_RASTER: - return VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE; + case VK_STATE_BIND_POINT_RASTER_LINE: + return VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE; + case VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS: + return VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE; case VK_STATE_BIND_POINT_COLOR_BLEND: return VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE; case VK_STATE_BIND_POINT_DEPTH_STENCIL: diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index 510af12..846cc5b 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -95,7 +95,8 @@ unordered_map renderPassMap; unordered_map framebufferMap; //unordered_map descriptorSetMap; unordered_map dynamicViewportStateMap; -unordered_map dynamicRasterStateMap; +unordered_map dynamicRasterLineStateMap; +unordered_map dynamicRasterDepthBiasStateMap; unordered_map dynamicColorBlendStateMap; unordered_map dynamicDepthStencilStateMap; @@ -224,10 +225,17 @@ static void* get_object_create_info(uint64_t handle, VkDbgObjectType type) return (void*)&(*it).second; break; } - case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE: + case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE: { - auto it = dynamicRasterStateMap.find(handle); - if (it != dynamicRasterStateMap.end()) + auto it = dynamicRasterLineStateMap.find(handle); + if (it != dynamicRasterLineStateMap.end()) + return (void*)&(*it).second; + break; + } + case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE: + { + auto it = dynamicRasterDepthBiasStateMap.find(handle); + if (it != dynamicRasterDepthBiasStateMap.end()) return (void*)&(*it).second; break; } @@ -511,10 +519,16 @@ static void add_object_create_info(const uint64_t handle, const VkDbgObjectType memcpy(pCI, pCreateInfo, sizeof(VkDynamicViewportStateCreateInfo)); break; } - case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE: + case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE: + { + auto pCI = &dynamicRasterLineStateMap[handle]; + memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterLineStateCreateInfo)); + break; + } + case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE: { - auto pCI = &dynamicRasterStateMap[handle]; - memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterStateCreateInfo)); + auto pCI = &dynamicRasterDepthBiasStateMap[handle]; + memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterDepthBiasStateCreateInfo)); break; } case VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE: @@ -1136,7 +1150,8 @@ static void print_object_list( print_object_map_members(dispObj, renderPassMap, VK_OBJECT_TYPE_RENDER_PASS, "RenderPass"); print_object_map_members(dispObj, framebufferMap, VK_OBJECT_TYPE_FRAMEBUFFER, "Framebuffer"); print_object_map_members(dispObj, dynamicViewportStateMap, VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE, "DynamicViewportState"); - print_object_map_members(dispObj, dynamicRasterStateMap, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, "DynamicRasterState"); + print_object_map_members(dispObj, dynamicRasterLineStateMap, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, "DynamicRasterLineState"); + print_object_map_members(dispObj, dynamicRasterDepthBiasStateMap, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, "DynamicRasterDepthBiasState"); print_object_map_members(dispObj, dynamicColorBlendStateMap, VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE, "DynamicColorBlendState"); print_object_map_members(dispObj, dynamicDepthStencilStateMap, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE, "DynamicDepthStencilState"); log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, 0, 0, MEMTRACK_NONE, "MEM", "*** End of Object lists ***"); @@ -1822,15 +1837,27 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, Vk return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState) { loader_platform_thread_lock_mutex(&globalLock); - auto item = dynamicRasterStateMap.find(dynamicRasterState.handle); - if (item != dynamicRasterStateMap.end()) { - dynamicRasterStateMap.erase(item); + auto item = dynamicRasterLineStateMap.find(dynamicRasterLineState.handle); + if (item != dynamicRasterLineStateMap.end()) { + dynamicRasterLineStateMap.erase(item); } loader_platform_thread_unlock_mutex(&globalLock); - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterState(device, dynamicRasterState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState); + return result; +} + +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +{ + loader_platform_thread_lock_mutex(&globalLock); + auto item = dynamicRasterDepthBiasStateMap.find(dynamicRasterDepthBiasState.handle); + if (item != dynamicRasterDepthBiasStateMap.end()) { + dynamicRasterDepthBiasStateMap.erase(item); + } + loader_platform_thread_unlock_mutex(&globalLock); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState); return result; } @@ -2284,15 +2311,29 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState( return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState( VkDevice device, - const VkDynamicRasterStateCreateInfo *pCreateInfo, - VkDynamicRasterState *pState) + const VkDynamicRasterLineStateCreateInfo *pCreateInfo, + VkDynamicRasterLineState *pState) { - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, pCreateInfo); + add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, pCreateInfo); + loader_platform_thread_unlock_mutex(&globalLock); + } + return result; +} + +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState( + VkDevice device, + const VkDynamicRasterDepthBiasStateCreateInfo *pCreateInfo, + VkDynamicRasterDepthBiasState *pState) +{ + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState); + if (result == VK_SUCCESS) { + loader_platform_thread_lock_mutex(&globalLock); + add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, pCreateInfo); loader_platform_thread_unlock_mutex(&globalLock); } return result; @@ -2435,11 +2476,33 @@ void VKAPI vkCmdBindDynamicViewportState( get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); } -void VKAPI vkCmdBindDynamicRasterState( +void VKAPI vkCmdBindDynamicRasterLineState( + VkCmdBuffer cmdBuffer, + VkDynamicRasterLineState dynamicRasterLineState) +{ + VkDynamicRasterLineStateCreateInfo* pCI; + loader_platform_thread_lock_mutex(&globalLock); + MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer); + if (!pCmdBuf) { + // TODO : Want cmdBuffer to be srcObj here + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, MEMTRACK_INVALID_CB, "MEM", + "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer); + } + pCI = (VkDynamicRasterLineStateCreateInfo*)get_object_create_info(dynamicRasterLineState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE); + if (!pCI) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, dynamicRasterLineState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", + "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterLineState.handle); + } + pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle; + loader_platform_thread_unlock_mutex(&globalLock); + get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState); +} + +void VKAPI vkCmdBindDynamicRasterDepthBiasState( VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState) + VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) { - VkDynamicRasterStateCreateInfo* pCI; + VkDynamicRasterDepthBiasStateCreateInfo* pCI; loader_platform_thread_lock_mutex(&globalLock); MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer); if (!pCmdBuf) { @@ -2447,14 +2510,14 @@ void VKAPI vkCmdBindDynamicRasterState( log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer); } - pCI = (VkDynamicRasterStateCreateInfo*)get_object_create_info(dynamicRasterState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE); + pCI = (VkDynamicRasterDepthBiasStateCreateInfo*)get_object_create_info(dynamicRasterDepthBiasState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE); if (!pCI) { - log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, dynamicRasterState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", - "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterState.handle); + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE, dynamicRasterDepthBiasState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", + "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterDepthBiasState.handle); } - pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle; + pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle; loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); + get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState); } void VKAPI vkCmdBindDynamicColorBlendState( @@ -3068,8 +3131,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( return (PFN_vkVoidFunction) vkDestroyFramebuffer; if (!strcmp(funcName, "vkDestroyDynamicViewportState")) return (PFN_vkVoidFunction) vkDestroyDynamicViewportState; - if (!strcmp(funcName, "vkDestroyDynamicRasterState")) - return (PFN_vkVoidFunction) vkDestroyDynamicRasterState; + if (!strcmp(funcName, "vkDestroyDynamicRasterLineState")) + return (PFN_vkVoidFunction) vkDestroyDynamicRasterLineState; + if (!strcmp(funcName, "vkDestroyDynamicRasterDepthBiasState")) + return (PFN_vkVoidFunction) vkDestroyDynamicRasterDepthBiasState; if (!strcmp(funcName, "vkDestroyDynamicColorBlendState")) return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState; if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState")) @@ -3124,8 +3189,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( return (PFN_vkVoidFunction) vkCreateSampler; if (!strcmp(funcName, "vkCreateDynamicViewportState")) return (PFN_vkVoidFunction) vkCreateDynamicViewportState; - if (!strcmp(funcName, "vkCreateDynamicRasterState")) - return (PFN_vkVoidFunction) vkCreateDynamicRasterState; + if (!strcmp(funcName, "vkCreateDynamicRasterLineState")) + return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState; + if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState")) + return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState; if (!strcmp(funcName, "vkCreateDynamicColorBlendState")) return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState; if (!strcmp(funcName, "vkCreateDynamicDepthStencilState")) @@ -3142,8 +3209,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( return (PFN_vkVoidFunction) vkCmdBindPipeline; if (!strcmp(funcName, "vkCmdBindDynamicViewportState")) return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState; - if (!strcmp(funcName, "vkCmdBindDynamicRasterState")) - return (PFN_vkVoidFunction) vkCmdBindDynamicRasterState; + if (!strcmp(funcName, "vkCmdBindDynamicRasterLineState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicRasterLineState; + if (!strcmp(funcName, "vkCmdBindDynamicRasterDepthBiasState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicRasterDepthBiasState; if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState")) return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState; if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState")) diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp index e769f13..27f5524 100644 --- a/layers/param_checker.cpp +++ b/layers/param_checker.cpp @@ -5843,16 +5843,16 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState( return result; } -bool PreCreateDynamicRasterState( +bool PreCreateDynamicRasterLineState( VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo) + const VkDynamicRasterLineStateCreateInfo* pCreateInfo) { if(pCreateInfo != nullptr) { - if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO) + if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO) { log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", - "vkCreateDynamicRasterState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); + "vkCreateDynamicRasterLineState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } } @@ -5860,9 +5860,9 @@ bool PreCreateDynamicRasterState( return true; } -bool PostCreateDynamicRasterState( +bool PostCreateDynamicRasterLineState( VkDevice device, - VkDynamicRasterState* pState, + VkDynamicRasterLineState* pState, VkResult result) { @@ -5872,7 +5872,7 @@ bool PostCreateDynamicRasterState( if(result < VK_SUCCESS) { - std::string reason = "vkCreateDynamicRasterState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkCreateDynamicRasterLineState parameter, VkResult result, is " + EnumeratorString(result); log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str()); return false; } @@ -5880,30 +5880,30 @@ bool PostCreateDynamicRasterState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState( VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState) + const VkDynamicRasterLineStateCreateInfo* pCreateInfo, + VkDynamicRasterLineState* pState) { - PreCreateDynamicRasterState(device, pCreateInfo); + PreCreateDynamicRasterLineState(device, pCreateInfo); - VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState); - PostCreateDynamicRasterState(device, pState, result); + PostCreateDynamicRasterLineState(device, pState, result); return result; } -bool PostDestroyDynamicRasterState( +bool PostDestroyDynamicRasterLineState( VkDevice device, - VkDynamicRasterState dynamicRasterState, + VkDynamicRasterLineState dynamicRasterLineState, VkResult result) { if(result < VK_SUCCESS) { - std::string reason = "vkDestroyDynamicRasterState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkDestroyDynamicRasterLineState parameter, VkResult result, is " + EnumeratorString(result); log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str()); return false; } @@ -5911,13 +5911,92 @@ bool PostDestroyDynamicRasterState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState( +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState( VkDevice device, - VkDynamicRasterState dynamicRasterState) + VkDynamicRasterLineState dynamicRasterLineState) { - VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterState(device, dynamicRasterState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState); - PostDestroyDynamicRasterState(device, dynamicRasterState, result); + PostDestroyDynamicRasterLineState(device, dynamicRasterLineState, result); + + return result; +} + +bool PreCreateDynamicRasterDepthBiasState( + VkDevice device, + const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo) +{ + if(pCreateInfo != nullptr) + { + if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO) + { + log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + "vkCreateDynamicRasterDepthBiasState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); + return false; + } + } + + return true; +} + +bool PostCreateDynamicRasterDepthBiasState( + VkDevice device, + VkDynamicRasterDepthBiasState* pState, + VkResult result) +{ + + if(pState != nullptr) + { + } + + if(result < VK_SUCCESS) + { + std::string reason = "vkCreateDynamicRasterDepthBiasState parameter, VkResult result, is " + EnumeratorString(result); + log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str()); + return false; + } + + return true; +} + +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState( + VkDevice device, + const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, + VkDynamicRasterDepthBiasState* pState) +{ + PreCreateDynamicRasterDepthBiasState(device, pCreateInfo); + + VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState); + + PostCreateDynamicRasterDepthBiasState(device, pState, result); + + return result; +} + +bool PostDestroyDynamicRasterDepthBiasState( + VkDevice device, + VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState, + VkResult result) +{ + + + if(result < VK_SUCCESS) + { + std::string reason = "vkDestroyDynamicRasterDepthBiasState parameter, VkResult result, is " + EnumeratorString(result); + log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str()); + return false; + } + + return true; +} + +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState( + VkDevice device, + VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +{ + VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState); + + PostDestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState, result); return result; } @@ -6745,22 +6824,40 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicViewportState( PostCmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); } -bool PostCmdBindDynamicRasterState( +bool PostCmdBindDynamicRasterLineState( + VkCmdBuffer cmdBuffer, + VkDynamicRasterLineState dynamicRasterLineState) +{ + + + return true; +} + +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState( + VkCmdBuffer cmdBuffer, + VkDynamicRasterLineState dynamicRasterLineState) +{ + get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState); + + PostCmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState); +} + +bool PostCmdBindDynamicRasterDepthBiasState( VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState) + VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) { return true; } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterState( +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState( VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState) + VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) { - get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); + get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState); - PostCmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); + PostCmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState); } bool PostCmdBindDynamicColorBlendState( @@ -8262,8 +8359,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, co return (PFN_vkVoidFunction) vkAllocDescriptorSets; if (!strcmp(funcName, "vkCreateDynamicViewportState")) return (PFN_vkVoidFunction) vkCreateDynamicViewportState; - if (!strcmp(funcName, "vkCreateDynamicRasterState")) - return (PFN_vkVoidFunction) vkCreateDynamicRasterState; + if (!strcmp(funcName, "vkCreateDynamicRasterLineState")) + return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState; + if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState")) + return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState; if (!strcmp(funcName, "vkCreateDynamicColorBlendState")) return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState; if (!strcmp(funcName, "vkCreateDynamicDepthStencilState")) diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h index 96c4f6a..bb79f03 100644 --- a/loader/gpa_helper.h +++ b/loader/gpa_helper.h @@ -215,10 +215,14 @@ static inline void* globalGetProcAddr(const char *name) return (void*) vkCreateDynamicViewportState; if (!strcmp(name, "DestroyDynamicViewportState")) return (void*) vkDestroyDynamicViewportState; - if (!strcmp(name, "CreateDynamicRasterState")) - return (void*) vkCreateDynamicRasterState; - if (!strcmp(name, "DestroyDynamicRasterState")) - return (void*) vkDestroyDynamicRasterState; + if (!strcmp(name, "CreateDynamicRasterLineState")) + return (void*) vkCreateDynamicRasterLineState; + if (!strcmp(name, "DestroyDynamicRasterLineState")) + return (void*) vkDestroyDynamicRasterLineState; + if (!strcmp(name, "CreateDynamicRasterDepthBiasState")) + return (void*) vkCreateDynamicRasterDepthBiasState; + if (!strcmp(name, "DestroyDynamicRasterDepthBiasState")) + return (void*) vkDestroyDynamicRasterDepthBiasState; if (!strcmp(name, "CreateDynamicColorBlendState")) return (void*) vkCreateDynamicColorBlendState; if (!strcmp(name, "DestroyDynamicColorBlendState")) @@ -257,8 +261,10 @@ static inline void* globalGetProcAddr(const char *name) return (void*) vkCmdBindPipeline; if (!strcmp(name, "CmdBindDynamicViewportState")) return (void*) vkCmdBindDynamicViewportState; - if (!strcmp(name, "CmdBindDynamicRasterState")) - return (void*) vkCmdBindDynamicRasterState; + if (!strcmp(name, "CmdBindDynamicRasterLineState")) + return (void*) vkCmdBindDynamicRasterLineState; + if (!strcmp(name, "CmdBindDynamicRasterDepthBiasState")) + return (void*) vkCmdBindDynamicRasterDepthBiasState; if (!strcmp(name, "CmdBindDynamicColorBlendState")) return (void*) vkCmdBindDynamicColorBlendState; if (!strcmp(name, "CmdBindDynamicDepthStencilState")) diff --git a/loader/table_ops.h b/loader/table_ops.h index 4003e9c..dbb0ee4 100644 --- a/loader/table_ops.h +++ b/loader/table_ops.h @@ -112,8 +112,10 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(dev, "vkUpdateDescriptorSets"); table->CreateDynamicViewportState = (PFN_vkCreateDynamicViewportState) gpa(dev, "vkCreateDynamicViewportState"); table->DestroyDynamicViewportState = (PFN_vkDestroyDynamicViewportState) gpa(dev, "vkDestroyDynamicViewportState"); - table->CreateDynamicRasterState = (PFN_vkCreateDynamicRasterState) gpa(dev, "vkCreateDynamicRasterState"); - table->DestroyDynamicRasterState = (PFN_vkDestroyDynamicRasterState) gpa(dev, "vkDestroyDynamicRasterState"); + table->CreateDynamicRasterLineState = (PFN_vkCreateDynamicRasterLineState) gpa(dev, "vkCreateDynamicRasterLineState"); + table->DestroyDynamicRasterLineState = (PFN_vkDestroyDynamicRasterLineState) gpa(dev, "vkDestroyDynamicRasterLineState"); + table->CreateDynamicRasterDepthBiasState = (PFN_vkCreateDynamicRasterDepthBiasState) gpa(dev, "vkCreateDynamicRasterDepthBiasState"); + table->DestroyDynamicRasterDepthBiasState = (PFN_vkDestroyDynamicRasterDepthBiasState) gpa(dev, "vkDestroyDynamicRasterDepthBiasState"); table->CreateDynamicColorBlendState = (PFN_vkCreateDynamicColorBlendState) gpa(dev, "vkCreateDynamicColorBlendState"); table->DestroyDynamicColorBlendState = (PFN_vkDestroyDynamicColorBlendState) gpa(dev, "vkDestroyDynamicColorBlendState"); table->CreateDynamicDepthStencilState = (PFN_vkCreateDynamicDepthStencilState) gpa(dev, "vkCreateDynamicDepthStencilState"); @@ -133,7 +135,8 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table table->ResetCommandBuffer = (PFN_vkResetCommandBuffer) gpa(dev, "vkResetCommandBuffer"); table->CmdBindPipeline = (PFN_vkCmdBindPipeline) gpa(dev, "vkCmdBindPipeline"); table->CmdBindDynamicViewportState = (PFN_vkCmdBindDynamicViewportState) gpa(dev, "vkCmdBindDynamicViewportState"); - table->CmdBindDynamicRasterState = (PFN_vkCmdBindDynamicRasterState) gpa(dev, "vkCmdBindDynamicRasterState"); + table->CmdBindDynamicRasterLineState = (PFN_vkCmdBindDynamicRasterLineState) gpa(dev, "vkCmdBindDynamicRasterLineState"); + table->CmdBindDynamicRasterDepthBiasState = (PFN_vkCmdBindDynamicRasterDepthBiasState) gpa(dev, "vkCmdBindDynamicRasterDepthBiasState"); table->CmdBindDynamicColorBlendState = (PFN_vkCmdBindDynamicColorBlendState) gpa(dev, "vkCmdBindDynamicColorBlendState"); table->CmdBindDynamicDepthStencilState = (PFN_vkCmdBindDynamicDepthStencilState) gpa(dev, "vkCmdBindDynamicDepthStencilState"); table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) gpa(dev, "vkCmdBindDescriptorSets"); @@ -344,10 +347,14 @@ static inline void *loader_lookup_device_dispatch_table( return (void *) table->CreateDynamicViewportState; if (!strcmp(name, "DestroyDynamicViewportState")) return (void *) table->DestroyDynamicViewportState; - if (!strcmp(name, "CreateDynamicRasterState")) - return (void *) table->CreateDynamicRasterState; - if (!strcmp(name, "DestroyDynamicRasterState")) - return (void *) table->DestroyDynamicRasterState; + if (!strcmp(name, "CreateDynamicRasterLineState")) + return (void *) table->CreateDynamicRasterLineState; + if (!strcmp(name, "DestroyDynamicRasterLineState")) + return (void *) table->DestroyDynamicRasterLineState; + if (!strcmp(name, "CreateDynamicRasterDepthBiasState")) + return (void *) table->CreateDynamicRasterDepthBiasState; + if (!strcmp(name, "DestroyDynamicRasterDepthBiasState")) + return (void *) table->DestroyDynamicRasterDepthBiasState; if (!strcmp(name, "CreateDynamicColorBlendState")) return (void *) table->CreateDynamicColorBlendState; if (!strcmp(name, "DestroyDynamicColorBlendState")) @@ -386,8 +393,10 @@ static inline void *loader_lookup_device_dispatch_table( return (void *) table->CmdBindPipeline; if (!strcmp(name, "CmdBindDynamicViewportState")) return (void *) table->CmdBindDynamicViewportState; - if (!strcmp(name, "CmdBindDynamicRasterState")) - return (void *) table->CmdBindDynamicRasterState; + if (!strcmp(name, "CmdBindDynamicRasterLineState")) + return (void *) table->CmdBindDynamicRasterLineState; + if (!strcmp(name, "CmdBindDynamicRasterDepthBiasState")) + return (void *) table->CmdBindDynamicRasterDepthBiasState; if (!strcmp(name, "CmdBindDynamicColorBlendState")) return (void *) table->CmdBindDynamicColorBlendState; if (!strcmp(name, "CmdBindDynamicDepthStencilState")) diff --git a/loader/trampoline.c b/loader/trampoline.c index 45a9ff7..715fcf7 100644 --- a/loader/trampoline.c +++ b/loader/trampoline.c @@ -1016,22 +1016,40 @@ LOADER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDy return disp->DestroyDynamicViewportState(device, dynamicViewportState); } -LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) +LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->CreateDynamicRasterState(device, pCreateInfo, pState); + return disp->CreateDynamicRasterLineState(device, pCreateInfo, pState); } -LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState) +LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->DestroyDynamicRasterState(device, dynamicRasterState); + return disp->DestroyDynamicRasterLineState(device, dynamicRasterLineState); +} + +LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState) +{ + const VkLayerDispatchTable *disp; + + disp = loader_get_dispatch(device); + + return disp->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState); +} + +LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +{ + const VkLayerDispatchTable *disp; + + disp = loader_get_dispatch(device); + + return disp->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState); } LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) @@ -1211,13 +1229,22 @@ LOADER_EXPORT void VKAPI vkCmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, Vk disp->CmdBindDynamicViewportState(cmdBuffer, state); } -LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, VkDynamicRasterState state) +LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState state) +{ + const VkLayerDispatchTable *disp; + + disp = loader_get_dispatch(cmdBuffer); + + disp->CmdBindDynamicRasterLineState(cmdBuffer, state); +} + +LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState state) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(cmdBuffer); - disp->CmdBindDynamicRasterState(cmdBuffer, state); + disp->CmdBindDynamicRasterDepthBiasState(cmdBuffer, state); } LOADER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState state) diff --git a/vk-layer-generate.py b/vk-layer-generate.py index 42db53c..4af3b37 100755 --- a/vk-layer-generate.py +++ b/vk-layer-generate.py @@ -1404,7 +1404,7 @@ class ObjectTrackerSubcommand(Subcommand): def generate_command_buffer_validates(self): cbv_txt = [] cbv_txt.append('%s' % self.lineinfo.get()) - for o in ['VkPipeline', 'VkDynamicViewportState', 'VkDynamicRasterState', 'VkDynamicColorBlendState', 'VkDynamicDepthStencilState', + for o in ['VkPipeline', 'VkDynamicViewportState', 'VkDynamicRasterLineState', 'VkDynamicRasterDepthBiasState', 'VkDynamicColorBlendState', 'VkDynamicDepthStencilState', 'VkPipelineLayout', 'VkBuffer', 'VkEvent', 'VkQueryPool', 'VkRenderPass', 'VkFramebuffer']: cbv_txt.append('static void validate_object(VkCmdBuffer dispatchable_object, %s object)' % (o)) cbv_txt.append('{') @@ -1597,7 +1597,8 @@ class ThreadingSubcommand(Subcommand): 'VkDescriptorPool' : 'VK_OBJECT_TYPE_DESCRIPTOR_POOL', 'VkDescriptorSet' : 'VK_OBJECT_TYPE_DESCRIPTOR_SET', 'VkDynamicViewportState' : 'VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE', - 'VkDynamicRasterState' : 'VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE', + 'VkDynamicRasterLineState' : 'VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE', + 'VkDynamicRasterDepthBiasState' : 'VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE', 'VkDynamicColorBlendState' : 'VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE', 'VkDynamicDepthStencilState' : 'VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE', 'VkFramebuffer' : 'VK_OBJECT_TYPE_FRAMEBUFFER', diff --git a/vulkan.py b/vulkan.py index 8843ee0..e7206b4 100755 --- a/vulkan.py +++ b/vulkan.py @@ -209,7 +209,8 @@ core = Extension( "VkDescriptorPool", "VkDescriptorSet", "VkDynamicViewportState", - "VkDynamicRasterState", + "VkDynamicRasterLineState", + "VkDynamicRasterDepthBiasState", "VkDynamicColorBlendState", "VkDynamicDepthStencilState", "VkRenderPass", @@ -672,14 +673,23 @@ core = Extension( [Param("VkDevice", "device"), Param("VkDynamicViewportState", "dynamicViewportState")]), - Proto("VkResult", "CreateDynamicRasterState", + Proto("VkResult", "CreateDynamicRasterLineState", [Param("VkDevice", "device"), - Param("const VkDynamicRasterStateCreateInfo*", "pCreateInfo"), - Param("VkDynamicRasterState*", "pState")]), + Param("const VkDynamicRasterLineStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicRasterLineState*", "pState")]), - Proto("VkResult", "DestroyDynamicRasterState", + Proto("VkResult", "DestroyDynamicRasterLineState", [Param("VkDevice", "device"), - Param("VkDynamicRasterState", "dynamicRasterState")]), + Param("VkDynamicRasterLineState", "dynamicRasterLineState")]), + + Proto("VkResult", "CreateDynamicRasterDepthBiasState", + [Param("VkDevice", "device"), + Param("const VkDynamicRasterDepthBiasStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicRasterDepthBiasState*", "pState")]), + + Proto("VkResult", "DestroyDynamicRasterDepthBiasState", + [Param("VkDevice", "device"), + Param("VkDynamicRasterDepthBiasState", "dynamicRasterDepthBiasState")]), Proto("VkResult", "CreateDynamicColorBlendState", [Param("VkDevice", "device"), @@ -742,9 +752,13 @@ core = Extension( [Param("VkCmdBuffer", "cmdBuffer"), Param("VkDynamicViewportState", "dynamicViewportState")]), - Proto("void", "CmdBindDynamicRasterState", + Proto("void", "CmdBindDynamicRasterLineState", + [Param("VkCmdBuffer", "cmdBuffer"), + Param("VkDynamicRasterLineState", "dynamicRasterLineState")]), + + Proto("void", "CmdBindDynamicRasterDepthBiasState", [Param("VkCmdBuffer", "cmdBuffer"), - Param("VkDynamicRasterState", "dynamicRasterState")]), + Param("VkDynamicRasterDepthBiasState", "dynamicRasterDepthBiasState")]), Proto("void", "CmdBindDynamicColorBlendState", [Param("VkCmdBuffer", "cmdBuffer"), @@ -1140,7 +1154,8 @@ object_non_dispatch_list = [ "VkDescriptorPool", "VkDescriptorSet", "VkDynamicViewportState", - "VkDynamicRasterState", + "VkDynamicRasterLineState", + "VkDynamicRasterDepthBiasState", "VkDynamicColorBlendState", "VkDynamicDepthStencilState", "VkRenderPass", -- 2.7.4