From 5e4125d22120c99efe93e9ed44e671c42a5486dc Mon Sep 17 00:00:00 2001 From: Cody Northrop Date: Wed, 26 Aug 2015 10:01:32 -0600 Subject: [PATCH] v156: Bug 14451 - Rename dynamic state objects --- demos/CMakeLists.txt~ | 117 ++++++++++++++++ demos/cube.c | 92 ++++++------ demos/tri.c | 92 ++++++------ icd/nulldrv/nulldrv.c | 108 +++++++------- icd/nulldrv/nulldrv.h | 8 +- include/vk_debug_report_lunarg.h | 24 ++-- include/vk_layer.h | 24 ++-- include/vulkan.h | 108 +++++++------- layers/draw_state.cpp | 256 +++++++++++++++++----------------- layers/draw_state.h | 24 ++-- layers/layer_common.h | 40 +++--- layers/mem_tracker.cpp | 256 +++++++++++++++++----------------- layers/param_checker.cpp | 224 ++++++++++++++--------------- layers/vk_validation_layer_details.md | 26 ++-- loader/gpa_helper.h | 48 +++---- loader/table_ops.h | 72 +++++----- loader/trampoline.c | 48 +++---- vk-layer-generate.py | 10 +- vulkan.py | 72 +++++----- 19 files changed, 883 insertions(+), 766 deletions(-) create mode 100644 demos/CMakeLists.txt~ diff --git a/demos/CMakeLists.txt~ b/demos/CMakeLists.txt~ new file mode 100644 index 0000000..803bef3 --- /dev/null +++ b/demos/CMakeLists.txt~ @@ -0,0 +1,117 @@ +if(NOT WIN32) + find_package(XCB REQUIRED) +endif() + +if(NOT WIN32) + if(NOT EXISTS /usr/include/glm/glm.hpp) + message(FATAL_ERROR "Necessary libglm-dev headers cannot be found: sudo apt-get install libglm-dev") + endif() + if(NOT EXISTS /usr/include/png.h) + message(FATAL_ERROR "Necessary png12-dev headers cannot be found: sudo apt-get install libpng12-dev") + endif() +endif() + +file(GLOB TEXTURES + "${PROJECT_SOURCE_DIR}/demos/*.png" + ) +file(COPY ${TEXTURES} DESTINATION ${CMAKE_BINARY_DIR}/demos) + +set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES") +set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_PROTOTYPES") + +set (LIBRARIES "vulkan") + +if(WIN32 AND CMAKE_BUILD_TYPE STREQUAL "Debug") + set(GLSLANG_BUILD ${GLSLANG_PREFIX}/dbuild) +else() + set(GLSLANG_BUILD ${GLSLANG_PREFIX}/build) +endif() + +if(NOT EXISTS ${GLSLANG_BUILD}/install/lib) + message(FATAL_ERROR "Necessary glslang libraries cannot be found: " ${GLSLANG_BUILD}/install/lib) +endif() + +if(WIN32) + add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-vert.spv + COMMAND ${GLSLANG_BUILD}/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/cube.vert + COMMAND move vert.spv ${CMAKE_BINARY_DIR}/demos/cube-vert.spv + DEPENDS cube.vert ${GLSLANG_BUILD}/install/bin/glslangValidator + ) + add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-frag.spv + COMMAND ${GLSLANG_BUILD}/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/cube.frag + COMMAND move frag.spv ${CMAKE_BINARY_DIR}/demos/cube-frag.spv + DEPENDS cube.frag ${GLSLANG_BUILD}/install/bin/glslangValidator + ) +endif() +if(NOT WIN32) + add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-vert.spv + COMMAND ${GLSLANG_BUILD}/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/cube.vert + COMMAND mv vert.spv ${CMAKE_BINARY_DIR}/demos/cube-vert.spv + DEPENDS cube.vert ${GLSLANG_BUILD}/install/bin/glslangValidator + ) + + add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/demos/cube-frag.spv + COMMAND ${GLSLANG_BUILD}/install/bin/glslangValidator -s -V ${PROJECT_SOURCE_DIR}/demos/cube.frag + COMMAND mv frag.spv ${CMAKE_BINARY_DIR}/demos/cube-frag.spv + DEPENDS cube.frag ${GLSLANG_BUILD}/install/bin/glslangValidator + ) +endif() + +if(NOT WIN32) + include_directories ( + ${XCB_INCLUDE_DIRS} + "${PROJECT_SOURCE_DIR}/icd/common" + ) + + link_libraries(${XCB_LIBRARIES} vulkan png m) +endif() +if(WIN32) + include_directories ( + "${PROJECT_SOURCE_DIR}/icd/common" + "${PROJECT_SOURCE_DIR}/libs/libpng" + "${PROJECT_SOURCE_DIR}/libs/zlib" + ) + + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_CRT_SECURE_NO_WARNINGS -D_USE_MATH_DEFINES") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_CRT_SECURE_NO_WARNINGS -D_USE_MATH_DEFINES") +endif() + +if(UNIX) + add_executable(vulkaninfo vulkaninfo.c) +else() + add_executable(vulkaninfo WIN32 vulkaninfo.c) +endif() +target_link_libraries(vulkaninfo ${LIBRARIES}) + +if(UNIX) + add_executable(tri tri.c) +else() + add_executable(tri WIN32 tri.c) +endif() +target_link_libraries(tri ${LIBRARIES}) + +if(NOT WIN32) + add_executable(cube cube.c ${CMAKE_BINARY_DIR}/demos/cube-vert.spv ${CMAKE_BINARY_DIR}/demos/cube-frag.spv) + target_link_libraries(cube ${LIBRARIES}) +else() + if (CMAKE_CL_64) + set (LIB_DIR "Win64") + else() + set (LIB_DIR "Win32") + endif() + add_library(libpngd STATIC IMPORTED) + set_target_properties(libpngd PROPERTIES IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/libs/${LIB_DIR}/libpngd.lib) + add_library(zlibd STATIC IMPORTED) + set_target_properties(zlibd PROPERTIES IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/libs/${LIB_DIR}/zlibd.lib) + add_executable(cube WIN32 cube.c ${CMAKE_BINARY_DIR}/demos/cube-vert.spv ${CMAKE_BINARY_DIR}/demos/cube-frag.spv) + target_link_libraries(cube ${LIBRARIES} libpngd zlibd) +endif() + + +if (${CMAKE_SYSTEM_NAME} MATCHES "Windows") + set(PATH_TO_WIN_VK ${CMAKE_CURRENT_BINARY_DIR}/../loader/${CMAKE_CFG_INTDIR}) + add_custom_command(TARGET tri + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different "${PATH_TO_WIN_VK}/vulkan.dll" $ + ) +endif() diff --git a/demos/cube.c b/demos/cube.c index 759e636..0bccae0 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -364,11 +364,11 @@ struct demo { VkRenderPass render_pass; VkPipeline pipeline; - VkDynamicViewportState viewport; - VkDynamicRasterLineState raster_line; - VkDynamicRasterDepthBiasState raster_depth_bias; - VkDynamicColorBlendState color_blend; - VkDynamicDepthState dynamic_depth; + VkDynamicViewportState dynamic_viewport; + VkDynamicLineWidthState dynamic_line_width; + VkDynamicDepthBiasState dynamic_depth_bias; + VkDynamicBlendState dynamic_blend; + VkDynamicDepthBoundsState dynamic_depth_bounds; VkDynamicStencilState dynamic_stencil; mat4x4 projection_matrix; @@ -541,11 +541,11 @@ static void demo_draw_build_cmd(struct demo *demo, VkCmdBuffer cmd_buf) vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout, 0, 1, &demo->desc_set, 0, NULL); - vkCmdBindDynamicViewportState(cmd_buf, demo->viewport); - vkCmdBindDynamicRasterLineState(cmd_buf, demo->raster_line); - vkCmdBindDynamicRasterDepthBiasState(cmd_buf, demo->raster_depth_bias); - vkCmdBindDynamicColorBlendState(cmd_buf, demo->color_blend); - vkCmdBindDynamicDepthState(cmd_buf, demo->dynamic_depth); + vkCmdBindDynamicViewportState(cmd_buf, demo->dynamic_viewport); + vkCmdBindDynamicLineWidthState(cmd_buf, demo->dynamic_line_width); + vkCmdBindDynamicDepthBiasState(cmd_buf, demo->dynamic_depth_bias); + vkCmdBindDynamicBlendState(cmd_buf, demo->dynamic_blend); + vkCmdBindDynamicDepthBoundsState(cmd_buf, demo->dynamic_depth_bounds); vkCmdBindDynamicStencilState(cmd_buf, demo->dynamic_stencil); vkCmdDraw(cmd_buf, 0, 12 * 3, 0, 1); @@ -1614,7 +1614,7 @@ static void demo_prepare_pipeline(struct demo *demo) ds.depthTestEnable = VK_TRUE; ds.depthWriteEnable = VK_TRUE; ds.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL; - ds.depthBoundsEnable = VK_FALSE; + ds.depthBoundsTestEnable = VK_FALSE; ds.back.stencilFailOp = VK_STENCIL_OP_KEEP; ds.back.stencilPassOp = VK_STENCIL_OP_KEEP; ds.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS; @@ -1670,10 +1670,10 @@ static void demo_prepare_pipeline(struct demo *demo) static void demo_prepare_dynamic_states(struct demo *demo) { VkDynamicViewportStateCreateInfo viewport_create; - VkDynamicRasterLineStateCreateInfo raster_line; - VkDynamicRasterDepthBiasStateCreateInfo raster_depth_bias; - VkDynamicColorBlendStateCreateInfo color_blend; - VkDynamicDepthStateCreateInfo depth; + VkDynamicLineWidthStateCreateInfo line_width; + VkDynamicDepthBiasStateCreateInfo depth_bias; + VkDynamicBlendStateCreateInfo blend; + VkDynamicDepthBoundsStateCreateInfo depth_bounds; VkDynamicStencilStateCreateInfo stencil; VkResult U_ASSERT_ONLY err; @@ -1695,49 +1695,49 @@ static void demo_prepare_dynamic_states(struct demo *demo) scissor.offset.y = 0; viewport_create.pScissors = &scissor; - 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(&line_width, 0, sizeof(line_width)); + line_width.sType = VK_STRUCTURE_TYPE_DYNAMIC_LINE_WIDTH_STATE_CREATE_INFO; + line_width.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(&depth_bias, 0, sizeof(depth_bias)); + depth_bias.sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_BIAS_STATE_CREATE_INFO; + depth_bias.depthBias = 0.0f; + depth_bias.depthBiasClamp = 0.0f; + depth_bias.slopeScaledDepthBias = 0.0f; - memset(&color_blend, 0, sizeof(color_blend)); - color_blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO; - color_blend.blendConst[0] = 1.0f; - color_blend.blendConst[1] = 1.0f; - color_blend.blendConst[2] = 1.0f; - color_blend.blendConst[3] = 1.0f; + memset(&blend, 0, sizeof(blend)); + blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_BLEND_STATE_CREATE_INFO; + blend.blendConst[0] = 1.0f; + blend.blendConst[1] = 1.0f; + blend.blendConst[2] = 1.0f; + blend.blendConst[3] = 1.0f; - memset(&depth, 0, sizeof(depth)); - depth.sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STATE_CREATE_INFO; - depth.minDepthBounds = 0.0f; - depth.maxDepthBounds = 1.0f; + memset(&depth_bounds, 0, sizeof(depth_bounds)); + depth_bounds.sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE_CREATE_INFO; + depth_bounds.minDepthBounds = 0.0f; + depth_bounds.maxDepthBounds = 1.0f; memset(&stencil, 0, sizeof(stencil)); stencil.sType = VK_STRUCTURE_TYPE_DYNAMIC_STENCIL_STATE_CREATE_INFO; stencil.stencilReference = 0; - stencil.stencilReadMask = 0xff; + stencil.stencilCompareMask = 0xff; stencil.stencilWriteMask = 0xff; - err = vkCreateDynamicViewportState(demo->device, &viewport_create, &demo->viewport); + err = vkCreateDynamicViewportState(demo->device, &viewport_create, &demo->dynamic_viewport); assert(!err); - err = vkCreateDynamicRasterLineState(demo->device, &raster_line, &demo->raster_line); + err = vkCreateDynamicLineWidthState(demo->device, &line_width, &demo->dynamic_line_width); assert(!err); - err = vkCreateDynamicRasterDepthBiasState(demo->device, &raster_depth_bias, &demo->raster_depth_bias); + err = vkCreateDynamicDepthBiasState(demo->device, &depth_bias, &demo->dynamic_depth_bias); assert(!err); - err = vkCreateDynamicColorBlendState(demo->device, - &color_blend, &demo->color_blend); + err = vkCreateDynamicBlendState(demo->device, + &blend, &demo->dynamic_blend); assert(!err); - err = vkCreateDynamicDepthState(demo->device, - &depth, &demo->dynamic_depth); + err = vkCreateDynamicDepthBoundsState(demo->device, + &depth_bounds, &demo->dynamic_depth_bounds); assert(!err); err = vkCreateDynamicStencilState(demo->device, @@ -1903,11 +1903,11 @@ static void demo_cleanup(struct demo *demo) vkFreeDescriptorSets(demo->device, demo->desc_pool, 1, &demo->desc_set); vkDestroyDescriptorPool(demo->device, demo->desc_pool); - vkDestroyDynamicViewportState(demo->device, demo->viewport); - vkDestroyDynamicRasterLineState(demo->device, demo->raster_line); - vkDestroyDynamicRasterDepthBiasState(demo->device, demo->raster_depth_bias); - vkDestroyDynamicColorBlendState(demo->device, demo->color_blend); - vkDestroyDynamicDepthState(demo->device, demo->dynamic_depth); + vkDestroyDynamicViewportState(demo->device, demo->dynamic_viewport); + vkDestroyDynamicLineWidthState(demo->device, demo->dynamic_line_width); + vkDestroyDynamicDepthBiasState(demo->device, demo->dynamic_depth_bias); + vkDestroyDynamicBlendState(demo->device, demo->dynamic_blend); + vkDestroyDynamicDepthBoundsState(demo->device, demo->dynamic_depth_bounds); vkDestroyDynamicStencilState(demo->device, demo->dynamic_stencil); vkDestroyPipeline(demo->device, demo->pipeline); diff --git a/demos/tri.c b/demos/tri.c index f515ae1..dfa55bc 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -216,11 +216,11 @@ struct demo { VkRenderPass render_pass; VkPipeline pipeline; - VkDynamicViewportState viewport; - VkDynamicRasterLineState raster_line; - VkDynamicRasterDepthBiasState raster_depth_bias; - VkDynamicColorBlendState color_blend; - VkDynamicDepthState dynamic_depth; + VkDynamicViewportState dynamic_viewport; + VkDynamicLineWidthState dynamic_line_width; + VkDynamicDepthBiasState dynamic_depth_bias; + VkDynamicBlendState dynamic_blend; + VkDynamicDepthBoundsState dynamic_depth_bounds; VkDynamicStencilState dynamic_stencil; VkShaderModule vert_shader_module; @@ -383,11 +383,11 @@ static void demo_draw_build_cmd(struct demo *demo) vkCmdBindDescriptorSets(demo->draw_cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout, 0, 1, & demo->desc_set, 0, NULL); - vkCmdBindDynamicViewportState(demo->draw_cmd, demo->viewport); - vkCmdBindDynamicRasterLineState(demo->draw_cmd, demo->raster_line); - vkCmdBindDynamicRasterDepthBiasState(demo->draw_cmd, demo->raster_depth_bias); - vkCmdBindDynamicColorBlendState(demo->draw_cmd, demo->color_blend); - vkCmdBindDynamicDepthState(demo->draw_cmd, demo->dynamic_depth); + vkCmdBindDynamicViewportState(demo->draw_cmd, demo->dynamic_viewport); + vkCmdBindDynamicLineWidthState(demo->draw_cmd, demo->dynamic_line_width); + vkCmdBindDynamicDepthBiasState(demo->draw_cmd, demo->dynamic_depth_bias); + vkCmdBindDynamicBlendState(demo->draw_cmd, demo->dynamic_blend); + vkCmdBindDynamicDepthBoundsState(demo->draw_cmd, demo->dynamic_depth_bounds); vkCmdBindDynamicStencilState(demo->draw_cmd, demo->dynamic_stencil); VkDeviceSize offsets[1] = {0}; @@ -1251,7 +1251,7 @@ static void demo_prepare_pipeline(struct demo *demo) ds.depthTestEnable = VK_TRUE; ds.depthWriteEnable = VK_TRUE; ds.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL; - ds.depthBoundsEnable = VK_FALSE; + ds.depthBoundsTestEnable = VK_FALSE; ds.back.stencilFailOp = VK_STENCIL_OP_KEEP; ds.back.stencilPassOp = VK_STENCIL_OP_KEEP; ds.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS; @@ -1307,10 +1307,10 @@ static void demo_prepare_pipeline(struct demo *demo) static void demo_prepare_dynamic_states(struct demo *demo) { VkDynamicViewportStateCreateInfo viewport_create; - VkDynamicRasterLineStateCreateInfo raster_line; - VkDynamicRasterDepthBiasStateCreateInfo raster_depth_bias; - VkDynamicColorBlendStateCreateInfo color_blend; - VkDynamicDepthStateCreateInfo depth; + VkDynamicLineWidthStateCreateInfo line_width; + VkDynamicDepthBiasStateCreateInfo depth_bias; + VkDynamicBlendStateCreateInfo blend; + VkDynamicDepthBoundsStateCreateInfo depth_bounds; VkDynamicStencilStateCreateInfo stencil; VkResult U_ASSERT_ONLY err; @@ -1332,49 +1332,49 @@ static void demo_prepare_dynamic_states(struct demo *demo) scissor.offset.y = 0; viewport_create.pScissors = &scissor; - 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(&line_width, 0, sizeof(line_width)); + line_width.sType = VK_STRUCTURE_TYPE_DYNAMIC_LINE_WIDTH_STATE_CREATE_INFO; + line_width.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(&depth_bias, 0, sizeof(depth_bias)); + depth_bias.sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_BIAS_STATE_CREATE_INFO; + depth_bias.depthBias = 0.0f; + depth_bias.depthBiasClamp = 0.0f; + depth_bias.slopeScaledDepthBias = 0.0f; - memset(&color_blend, 0, sizeof(color_blend)); - color_blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO; - color_blend.blendConst[0] = 1.0f; - color_blend.blendConst[1] = 1.0f; - color_blend.blendConst[2] = 1.0f; - color_blend.blendConst[3] = 1.0f; + memset(&blend, 0, sizeof(blend)); + blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_BLEND_STATE_CREATE_INFO; + blend.blendConst[0] = 1.0f; + blend.blendConst[1] = 1.0f; + blend.blendConst[2] = 1.0f; + blend.blendConst[3] = 1.0f; - memset(&depth, 0, sizeof(depth)); - depth.sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STATE_CREATE_INFO; - depth.minDepthBounds = 0.0f; - depth.maxDepthBounds = 1.0f; + memset(&depth_bounds, 0, sizeof(depth_bounds)); + depth_bounds.sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE_CREATE_INFO; + depth_bounds.minDepthBounds = 0.0f; + depth_bounds.maxDepthBounds = 1.0f; memset(&stencil, 0, sizeof(stencil)); stencil.sType = VK_STRUCTURE_TYPE_DYNAMIC_STENCIL_STATE_CREATE_INFO; stencil.stencilReference = 0; - stencil.stencilReadMask = 0xff; + stencil.stencilCompareMask = 0xff; stencil.stencilWriteMask = 0xff; - err = vkCreateDynamicViewportState(demo->device, &viewport_create, &demo->viewport); + err = vkCreateDynamicViewportState(demo->device, &viewport_create, &demo->dynamic_viewport); assert(!err); - err = vkCreateDynamicRasterLineState(demo->device, &raster_line, &demo->raster_line); + err = vkCreateDynamicLineWidthState(demo->device, &line_width, &demo->dynamic_line_width); assert(!err); - err = vkCreateDynamicRasterDepthBiasState(demo->device, &raster_depth_bias, &demo->raster_depth_bias); + err = vkCreateDynamicDepthBiasState(demo->device, &depth_bias, &demo->dynamic_depth_bias); assert(!err); - err = vkCreateDynamicColorBlendState(demo->device, - &color_blend, &demo->color_blend); + err = vkCreateDynamicBlendState(demo->device, + &blend, &demo->dynamic_blend); assert(!err); - err = vkCreateDynamicDepthState(demo->device, - &depth, &demo->dynamic_depth); + err = vkCreateDynamicDepthBoundsState(demo->device, + &depth_bounds, &demo->dynamic_depth_bounds); assert(!err); err = vkCreateDynamicStencilState(demo->device, @@ -2123,11 +2123,11 @@ static void demo_cleanup(struct demo *demo) vkDestroyCommandBuffer(demo->device, demo->draw_cmd); vkDestroyCommandPool(demo->device, demo->cmd_pool); - vkDestroyDynamicViewportState(demo->device, demo->viewport); - vkDestroyDynamicRasterLineState(demo->device, demo->raster_line); - vkDestroyDynamicRasterDepthBiasState(demo->device, demo->raster_depth_bias); - vkDestroyDynamicColorBlendState(demo->device, demo->color_blend); - vkDestroyDynamicDepthState(demo->device, demo->dynamic_depth); + vkDestroyDynamicViewportState(demo->device, demo->dynamic_viewport); + vkDestroyDynamicLineWidthState(demo->device, demo->dynamic_line_width); + vkDestroyDynamicDepthBiasState(demo->device, demo->dynamic_depth_bias); + vkDestroyDynamicBlendState(demo->device, demo->dynamic_blend); + vkDestroyDynamicDepthBoundsState(demo->device, demo->dynamic_depth_bounds); vkDestroyDynamicStencilState(demo->device, demo->dynamic_stencil); vkDestroyPipeline(demo->device, demo->pipeline); diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c index 1a5a158..7151b9d 100644 --- a/icd/nulldrv/nulldrv.c +++ b/icd/nulldrv/nulldrv.c @@ -518,14 +518,14 @@ static VkResult nulldrv_viewport_state_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VkResult nulldrv_raster_line_state_create(struct nulldrv_dev *dev, - const VkDynamicRasterLineStateCreateInfo *info, - struct nulldrv_dynamic_rs_line **state_ret) +static VkResult nulldrv_line_width_state_create(struct nulldrv_dev *dev, + const VkDynamicLineWidthStateCreateInfo *info, + struct nulldrv_dynamic_line_width **state_ret) { - struct nulldrv_dynamic_rs_line *state; + struct nulldrv_dynamic_line_width *state; - state = (struct nulldrv_dynamic_rs_line *) nulldrv_base_create(dev, - sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE); + state = (struct nulldrv_dynamic_line_width *) nulldrv_base_create(dev, + sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE); if (!state) return VK_ERROR_OUT_OF_HOST_MEMORY; @@ -534,14 +534,14 @@ static VkResult nulldrv_raster_line_state_create(struct nulldrv_dev *dev, 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) +static VkResult nulldrv_depth_bias_state_create(struct nulldrv_dev *dev, + const VkDynamicDepthBiasStateCreateInfo *info, + struct nulldrv_dynamic_depth_bias **state_ret) { - struct nulldrv_dynamic_rs_depth_bias *state; + struct nulldrv_dynamic_depth_bias *state; - state = (struct nulldrv_dynamic_rs_depth_bias *) nulldrv_base_create(dev, - sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE); + state = (struct nulldrv_dynamic_depth_bias *) nulldrv_base_create(dev, + sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE); if (!state) return VK_ERROR_OUT_OF_HOST_MEMORY; @@ -551,13 +551,13 @@ static VkResult nulldrv_raster_depth_bias_state_create(struct nulldrv_dev *dev, } static VkResult nulldrv_blend_state_create(struct nulldrv_dev *dev, - const VkDynamicColorBlendStateCreateInfo *info, - struct nulldrv_dynamic_cb **state_ret) + const VkDynamicBlendStateCreateInfo *info, + struct nulldrv_dynamic_blend **state_ret) { - struct nulldrv_dynamic_cb *state; + struct nulldrv_dynamic_blend *state; - state = (struct nulldrv_dynamic_cb *) nulldrv_base_create(dev, - sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE); + state = (struct nulldrv_dynamic_blend *) nulldrv_base_create(dev, + sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE); if (!state) return VK_ERROR_OUT_OF_HOST_MEMORY; @@ -566,14 +566,14 @@ static VkResult nulldrv_blend_state_create(struct nulldrv_dev *dev, return VK_SUCCESS; } -static VkResult nulldrv_depth_state_create(struct nulldrv_dev *dev, - const VkDynamicDepthStateCreateInfo *info, - struct nulldrv_dynamic_depth **state_ret) +static VkResult nulldrv_depth_bounds_state_create(struct nulldrv_dev *dev, + const VkDynamicDepthBoundsStateCreateInfo *info, + struct nulldrv_dynamic_depth_bounds **state_ret) { - struct nulldrv_dynamic_depth *state; + struct nulldrv_dynamic_depth_bounds *state; - state = (struct nulldrv_dynamic_depth *) nulldrv_base_create(dev, - sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE); + state = (struct nulldrv_dynamic_depth_bounds *) nulldrv_base_create(dev, + sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE); if (!state) return VK_ERROR_OUT_OF_HOST_MEMORY; @@ -1210,30 +1210,30 @@ ICD_EXPORT void VKAPI vkCmdBindDynamicViewportState( NULLDRV_LOG_FUNC; } -ICD_EXPORT void VKAPI vkCmdBindDynamicRasterLineState( +ICD_EXPORT void VKAPI vkCmdBindDynamicLineWidthState( VkCmdBuffer cmdBuffer, - VkDynamicRasterLineState state) + VkDynamicLineWidthState state) { NULLDRV_LOG_FUNC; } -ICD_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState( +ICD_EXPORT void VKAPI vkCmdBindDynamicDepthBiasState( VkCmdBuffer cmdBuffer, - VkDynamicRasterDepthBiasState state) + VkDynamicDepthBiasState state) { NULLDRV_LOG_FUNC; } -ICD_EXPORT void VKAPI vkCmdBindDynamicColorBlendState( +ICD_EXPORT void VKAPI vkCmdBindDynamicBlendState( VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState state) + VkDynamicBlendState state) { NULLDRV_LOG_FUNC; } -ICD_EXPORT void VKAPI vkCmdBindDynamicDepthState( +ICD_EXPORT void VKAPI vkCmdBindDynamicDepthBoundsState( VkCmdBuffer cmdBuffer, - VkDynamicDepthState state) + VkDynamicDepthBoundsState state) { NULLDRV_LOG_FUNC; } @@ -2115,50 +2115,50 @@ ICD_EXPORT VkResult VKAPI vkDestroyDynamicViewportState( return VK_SUCCESS; } -ICD_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState( +ICD_EXPORT VkResult VKAPI vkCreateDynamicLineWidthState( VkDevice device, - const VkDynamicRasterLineStateCreateInfo* pCreateInfo, - VkDynamicRasterLineState* pState) + const VkDynamicLineWidthStateCreateInfo* pCreateInfo, + VkDynamicLineWidthState* pState) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); - return nulldrv_raster_line_state_create(dev, pCreateInfo, + return nulldrv_line_width_state_create(dev, pCreateInfo, (struct nulldrv_dynamic_rs_line **) pState); } -ICD_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState( +ICD_EXPORT VkResult VKAPI vkCreateDynamicDepthBiasState( VkDevice device, - const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, - VkDynamicRasterDepthBiasState* pState) + const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, + VkDynamicDepthBiasState* pState) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); - return nulldrv_raster_depth_bias_state_create(dev, pCreateInfo, + return nulldrv_depth_bias_state_create(dev, pCreateInfo, (struct nulldrv_dynamic_rs_depth_bias **) pState); } -ICD_EXPORT VkResult VKAPI vkDestroyDynamicRasterLinesState( +ICD_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthsState( VkDevice device, - VkDynamicRasterLineState dynamicRasterLineState) + VkDynamicLineWidthState dynamicLineWidthState) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState( +ICD_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState( VkDevice device, - VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) + VkDynamicDepthBiasState dynamicDepthBiasState) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState( +ICD_EXPORT VkResult VKAPI vkCreateDynamicBlendState( VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState) + const VkDynamicBlendStateCreateInfo* pCreateInfo, + VkDynamicBlendState* pState) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); @@ -2167,29 +2167,29 @@ ICD_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState( (struct nulldrv_dynamic_cb **) pState); } -ICD_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState( +ICD_EXPORT VkResult VKAPI vkDestroyDynamicBlendState( VkDevice device, - VkDynamicColorBlendState dynamicColorBlendState) + VkDynamicBlendState dynamicBlendState) { NULLDRV_LOG_FUNC; return VK_SUCCESS; } -ICD_EXPORT VkResult VKAPI vkCreateDynamicDepthState( +ICD_EXPORT VkResult VKAPI vkCreateDynamicDepthBoundsState( VkDevice device, - const VkDynamicDepthStateCreateInfo* pCreateInfo, - VkDynamicDepthState* pState) + const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, + VkDynamicDepthBoundsState* pState) { NULLDRV_LOG_FUNC; struct nulldrv_dev *dev = nulldrv_dev(device); - return nulldrv_depth_state_create(dev, pCreateInfo, + return nulldrv_depth_bounds_state_create(dev, pCreateInfo, (struct nulldrv_dynamic_depth **) pState); } -ICD_EXPORT VkResult VKAPI vkDestroyDynamicDepthState( +ICD_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState( VkDevice device, - VkDynamicDepthState dynamicDepthState) + VkDynamicDepthBoundsState dynamicDepthBoundsState) { NULLDRV_LOG_FUNC; return VK_SUCCESS; diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h index bf02629..8108823 100644 --- a/icd/nulldrv/nulldrv.h +++ b/icd/nulldrv/nulldrv.h @@ -148,19 +148,19 @@ struct nulldrv_dynamic_vp { struct nulldrv_obj obj; }; -struct nulldrv_dynamic_rs_line { +struct nulldrv_dynamic_line_width { struct nulldrv_obj obj; }; -struct nulldrv_dynamic_rs_depth_bias { +struct nulldrv_dynamic_depth_bias { struct nulldrv_obj obj; }; -struct nulldrv_dynamic_cb { +struct nulldrv_dynamic_blend { struct nulldrv_obj obj; }; -struct nulldrv_dynamic_depth { +struct nulldrv_dynamic_depth_bounds { struct nulldrv_obj obj; }; diff --git a/include/vk_debug_report_lunarg.h b/include/vk_debug_report_lunarg.h index e466e0a..166ed73 100644 --- a/include/vk_debug_report_lunarg.h +++ b/include/vk_debug_report_lunarg.h @@ -67,10 +67,10 @@ 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_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_STATE = 24, + VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE = 21, + VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE = 22, + VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE = 23, + VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE = 24, VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE = 25, VK_OBJECT_TYPE_FENCE = 26, VK_OBJECT_TYPE_SEMAPHORE = 27, @@ -111,16 +111,16 @@ static inline const char* string_VkDbgObjectType(VkDbgObjectType input_value) return "VK_OBJECT_TYPE_DEVICE"; case VK_OBJECT_TYPE_DEVICE_MEMORY: return "VK_OBJECT_TYPE_DEVICE_MEMORY"; - case VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE: - return "VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE"; - case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE: - return "VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE"; + case VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE"; + case VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE"; case VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE: return "VK_OBJECT_TYPE_DYNAMIC_STENCIL_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_LINE_WIDTH_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE"; + case VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_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 028da8a..9e5cf4e 100644 --- a/include/vk_layer.h +++ b/include/vk_layer.h @@ -104,14 +104,14 @@ typedef struct VkLayerDispatchTable_ PFN_vkUpdateDescriptorSets UpdateDescriptorSets; PFN_vkCreateDynamicViewportState CreateDynamicViewportState; PFN_vkDestroyDynamicViewportState DestroyDynamicViewportState; - PFN_vkCreateDynamicRasterLineState CreateDynamicRasterLineState; - PFN_vkDestroyDynamicRasterLineState DestroyDynamicRasterLineState; - PFN_vkCreateDynamicRasterDepthBiasState CreateDynamicRasterDepthBiasState; - PFN_vkDestroyDynamicRasterDepthBiasState DestroyDynamicRasterDepthBiasState; - PFN_vkCreateDynamicColorBlendState CreateDynamicColorBlendState; - PFN_vkDestroyDynamicColorBlendState DestroyDynamicColorBlendState; - PFN_vkCreateDynamicDepthState CreateDynamicDepthState; - PFN_vkDestroyDynamicDepthState DestroyDynamicDepthState; + PFN_vkCreateDynamicLineWidthState CreateDynamicLineWidthState; + PFN_vkDestroyDynamicLineWidthState DestroyDynamicLineWidthState; + PFN_vkCreateDynamicDepthBiasState CreateDynamicDepthBiasState; + PFN_vkDestroyDynamicDepthBiasState DestroyDynamicDepthBiasState; + PFN_vkCreateDynamicBlendState CreateDynamicBlendState; + PFN_vkDestroyDynamicBlendState DestroyDynamicBlendState; + PFN_vkCreateDynamicDepthBoundsState CreateDynamicDepthBoundsState; + PFN_vkDestroyDynamicDepthBoundsState DestroyDynamicDepthBoundsState; PFN_vkCreateDynamicStencilState CreateDynamicStencilState; PFN_vkDestroyDynamicStencilState DestroyDynamicStencilState; PFN_vkCreateFramebuffer CreateFramebuffer; @@ -129,10 +129,10 @@ typedef struct VkLayerDispatchTable_ PFN_vkResetCommandBuffer ResetCommandBuffer; PFN_vkCmdBindPipeline CmdBindPipeline; PFN_vkCmdBindDynamicViewportState CmdBindDynamicViewportState; - PFN_vkCmdBindDynamicRasterLineState CmdBindDynamicRasterLineState; - PFN_vkCmdBindDynamicRasterDepthBiasState CmdBindDynamicRasterDepthBiasState; - PFN_vkCmdBindDynamicColorBlendState CmdBindDynamicColorBlendState; - PFN_vkCmdBindDynamicDepthState CmdBindDynamicDepthState; + PFN_vkCmdBindDynamicLineWidthState CmdBindDynamicLineWidthState; + PFN_vkCmdBindDynamicDepthBiasState CmdBindDynamicDepthBiasState; + PFN_vkCmdBindDynamicBlendState CmdBindDynamicBlendState; + PFN_vkCmdBindDynamicDepthBoundsState CmdBindDynamicDepthBoundsState; PFN_vkCmdBindDynamicStencilState CmdBindDynamicStencilState; PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets; PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers; diff --git a/include/vulkan.h b/include/vulkan.h index 3b4354d..65efec2 100644 --- a/include/vulkan.h +++ b/include/vulkan.h @@ -119,10 +119,10 @@ VK_DEFINE_NONDISP_HANDLE(VkSampler) VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool) VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) VK_DEFINE_NONDISP_HANDLE(VkDynamicViewportState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterLineState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterDepthBiasState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicColorBlendState) -VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicLineWidthState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthBiasState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicBlendState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthBoundsState) VK_DEFINE_NONDISP_HANDLE(VkDynamicStencilState) VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) VK_DEFINE_NONDISP_HANDLE(VkCmdPool) @@ -201,10 +201,10 @@ 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_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_STATE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_DYNAMIC_LINE_WIDTH_STATE_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_BIAS_STATE_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_DYNAMIC_BLEND_STATE_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE_CREATE_INFO = 14, VK_STRUCTURE_TYPE_DYNAMIC_STENCIL_STATE_CREATE_INFO = 15, VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 16, VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 17, @@ -1670,7 +1670,7 @@ typedef struct { VkBool32 depthTestEnable; VkBool32 depthWriteEnable; VkCompareOp depthCompareOp; - VkBool32 depthBoundsEnable; + VkBool32 depthBoundsTestEnable; VkBool32 stencilTestEnable; VkStencilOpState front; VkStencilOpState back; @@ -1856,7 +1856,7 @@ typedef struct { VkStructureType sType; const void* pNext; float lineWidth; -} VkDynamicRasterLineStateCreateInfo; +} VkDynamicLineWidthStateCreateInfo; typedef struct { VkStructureType sType; @@ -1864,25 +1864,25 @@ typedef struct { float depthBias; float depthBiasClamp; float slopeScaledDepthBias; -} VkDynamicRasterDepthBiasStateCreateInfo; +} VkDynamicDepthBiasStateCreateInfo; typedef struct { VkStructureType sType; const void* pNext; float blendConst[4]; -} VkDynamicColorBlendStateCreateInfo; +} VkDynamicBlendStateCreateInfo; typedef struct { VkStructureType sType; const void* pNext; float minDepthBounds; float maxDepthBounds; -} VkDynamicDepthStateCreateInfo; +} VkDynamicDepthBoundsStateCreateInfo; typedef struct { VkStructureType sType; const void* pNext; - uint32_t stencilReadMask; + uint32_t stencilCompareMask; uint32_t stencilWriteMask; uint32_t stencilReference; } VkDynamicStencilStateCreateInfo; @@ -2195,14 +2195,14 @@ 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_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_vkCreateDynamicDepthState)(VkDevice device, const VkDynamicDepthStateCreateInfo* pCreateInfo, VkDynamicDepthState* pState); -typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthState)(VkDevice device, VkDynamicDepthState dynamicDepthState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicLineWidthState)(VkDevice device, const VkDynamicLineWidthStateCreateInfo* pCreateInfo, VkDynamicLineWidthState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicLineWidthState)(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthBiasState)(VkDevice device, const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, VkDynamicDepthBiasState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthBiasState)(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicBlendState)(VkDevice device, const VkDynamicBlendStateCreateInfo* pCreateInfo, VkDynamicBlendState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicBlendState)(VkDevice device, VkDynamicBlendState dynamicBlendState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthBoundsState)(VkDevice device, const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, VkDynamicDepthBoundsState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthBoundsState)(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState); typedef VkResult (VKAPI *PFN_vkCreateDynamicStencilState)(VkDevice device, const VkDynamicStencilStateCreateInfo* pCreateInfoFront, const VkDynamicStencilStateCreateInfo* pCreateInfoBack, VkDynamicStencilState* pState); typedef VkResult (VKAPI *PFN_vkDestroyDynamicStencilState)(VkDevice device, VkDynamicStencilState dynamicStencilState); typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); @@ -2220,10 +2220,10 @@ 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_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_vkCmdBindDynamicDepthState)(VkCmdBuffer cmdBuffer, VkDynamicDepthState dynamicDepthState); +typedef void (VKAPI *PFN_vkCmdBindDynamicLineWidthState)(VkCmdBuffer cmdBuffer, VkDynamicLineWidthState dynamicLineWidthState); +typedef void (VKAPI *PFN_vkCmdBindDynamicDepthBiasState)(VkCmdBuffer cmdBuffer, VkDynamicDepthBiasState dynamicDepthBiasState); +typedef void (VKAPI *PFN_vkCmdBindDynamicBlendState)(VkCmdBuffer cmdBuffer, VkDynamicBlendState dynamicBlendState); +typedef void (VKAPI *PFN_vkCmdBindDynamicDepthBoundsState)(VkCmdBuffer cmdBuffer, VkDynamicDepthBoundsState dynamicDepthBoundsState); typedef void (VKAPI *PFN_vkCmdBindDynamicStencilState)(VkCmdBuffer cmdBuffer, VkDynamicStencilState dynamicStencilState); 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); @@ -2718,41 +2718,41 @@ VkResult VKAPI vkDestroyDynamicViewportState( VkDevice device, VkDynamicViewportState dynamicViewportState); -VkResult VKAPI vkCreateDynamicRasterLineState( +VkResult VKAPI vkCreateDynamicLineWidthState( VkDevice device, - const VkDynamicRasterLineStateCreateInfo* pCreateInfo, - VkDynamicRasterLineState* pState); + const VkDynamicLineWidthStateCreateInfo* pCreateInfo, + VkDynamicLineWidthState* pState); -VkResult VKAPI vkDestroyDynamicRasterLineState( +VkResult VKAPI vkDestroyDynamicLineWidthState( VkDevice device, - VkDynamicRasterLineState dynamicRasterLineState); + VkDynamicLineWidthState dynamicLineWidthState); -VkResult VKAPI vkCreateDynamicRasterDepthBiasState( +VkResult VKAPI vkCreateDynamicDepthBiasState( VkDevice device, - const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, - VkDynamicRasterDepthBiasState* pState); + const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, + VkDynamicDepthBiasState* pState); -VkResult VKAPI vkDestroyDynamicRasterDepthBiasState( +VkResult VKAPI vkDestroyDynamicDepthBiasState( VkDevice device, - VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState); + VkDynamicDepthBiasState dynamicDepthBiasState); -VkResult VKAPI vkCreateDynamicColorBlendState( +VkResult VKAPI vkCreateDynamicBlendState( VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState); + const VkDynamicBlendStateCreateInfo* pCreateInfo, + VkDynamicBlendState* pState); -VkResult VKAPI vkDestroyDynamicColorBlendState( +VkResult VKAPI vkDestroyDynamicBlendState( VkDevice device, - VkDynamicColorBlendState dynamicColorBlendState); + VkDynamicBlendState dynamicBlendState); -VkResult VKAPI vkCreateDynamicDepthState( +VkResult VKAPI vkCreateDynamicDepthBoundsState( VkDevice device, - const VkDynamicDepthStateCreateInfo* pCreateInfo, - VkDynamicDepthState* pState); + const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, + VkDynamicDepthBoundsState* pState); -VkResult VKAPI vkDestroyDynamicDepthState( +VkResult VKAPI vkDestroyDynamicDepthBoundsState( VkDevice device, - VkDynamicDepthState dynamicDepthState); + VkDynamicDepthBoundsState dynamicDepthBoundsState); VkResult VKAPI vkCreateDynamicStencilState( VkDevice device, @@ -2830,21 +2830,21 @@ void VKAPI vkCmdBindDynamicViewportState( VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState); -void VKAPI vkCmdBindDynamicRasterLineState( +void VKAPI vkCmdBindDynamicLineWidthState( VkCmdBuffer cmdBuffer, - VkDynamicRasterLineState dynamicRasterLineState); + VkDynamicLineWidthState dynamicLineWidthState); -void VKAPI vkCmdBindDynamicRasterDepthBiasState( +void VKAPI vkCmdBindDynamicDepthBiasState( VkCmdBuffer cmdBuffer, - VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState); + VkDynamicDepthBiasState dynamicDepthBiasState); -void VKAPI vkCmdBindDynamicColorBlendState( +void VKAPI vkCmdBindDynamicBlendState( VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState); + VkDynamicBlendState dynamicBlendState); -void VKAPI vkCmdBindDynamicDepthState( +void VKAPI vkCmdBindDynamicDepthBoundsState( VkCmdBuffer cmdBuffer, - VkDynamicDepthState dynamicDepthState); + VkDynamicDepthBoundsState dynamicDepthBoundsState); void VKAPI vkCmdBindDynamicStencilState( VkCmdBuffer cmdBuffer, diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index a05fc65..bbadcaf 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -65,10 +65,10 @@ unordered_map imageMap; unordered_map viewMap; unordered_map bufferMap; unordered_map dynamicVpStateMap; -unordered_map dynamicRasterLineStateMap; -unordered_map dynamicRasterDepthBiasStateMap; -unordered_map dynamicCbStateMap; -unordered_map dynamicDepthStateMap; +unordered_map dynamicLineWidthStateMap; +unordered_map dynamicDepthBiasStateMap; +unordered_map dynamicBlendStateMap; +unordered_map dynamicDepthBoundsStateMap; unordered_map> dynamicStencilStateMap; unordered_map pipelineMap; unordered_map poolMap; @@ -142,14 +142,14 @@ static string cmdTypeToString(CMD_TYPE cmd) return "CMD_BINDPIPELINEDELTA"; case CMD_BINDDYNAMICVIEWPORTSTATE: return "CMD_BINDDYNAMICVIEWPORTSTATE"; - case CMD_BINDDYNAMICRASTERLINESTATE: - return "CMD_BINDDYNAMICRASTERLINESTATE"; - case CMD_BINDDYNAMICRASTERDEPTHBIASSTATE: - return "CMD_BINDDYNAMICRASTERDEPTHBIASSTATE"; - case CMD_BINDDYNAMICCOLORBLENDSTATE: - return "CMD_BINDDYNAMICCOLORBLENDSTATE"; - case CMD_BINDDYNAMICDEPTHSTATE: - return "CMD_BINDDYNAMICDEPTHSTATE"; + case CMD_BINDDYNAMICLINEWIDTHSTATE: + return "CMD_BINDDYNAMICLINEWIDTHSTATE"; + case CMD_BINDDYNAMICDEPTHBIASSTATE: + return "CMD_BINDDYNAMICDEPTHBIASSTATE"; + case CMD_BINDDYNAMICBLENDSTATE: + return "CMD_BINDDYNAMICBLENDSTATE"; + case CMD_BINDDYNAMICDEPTHBOUNDSSTATE: + return "CMD_BINDDYNAMICDEPTHBOUNDSSTATE"; case CMD_BINDDYNAMICSTENCILSTATE: return "CMD_BINDDYNAMICSTENCILSTATE"; case CMD_BINDDESCRIPTORSETS: @@ -263,10 +263,10 @@ static void deleteDynamicState() delete[] (*ii).second.pViewports; } dynamicVpStateMap.clear(); - dynamicRasterLineStateMap.clear(); - dynamicRasterDepthBiasStateMap.clear(); - dynamicCbStateMap.clear(); - dynamicDepthStateMap.clear(); + dynamicLineWidthStateMap.clear(); + dynamicDepthBiasStateMap.clear(); + dynamicBlendStateMap.clear(); + dynamicDepthBoundsStateMap.clear(); dynamicStencilStateMap.clear(); } // Free all sampler nodes @@ -366,14 +366,14 @@ 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_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: - return (void*)&dynamicDepthStateMap[handle]; + case VK_STATE_BIND_POINT_LINE_WIDTH: + return (void*)&dynamicLineWidthStateMap[handle]; + case VK_STATE_BIND_POINT_DEPTH_BIAS: + return (void*)&dynamicDepthBiasStateMap[handle]; + case VK_STATE_BIND_POINT_BLEND: + return (void*)&dynamicBlendStateMap[handle]; + case VK_STATE_BIND_POINT_DEPTH_BOUNDS: + return (void*)&dynamicDepthBoundsStateMap[handle]; case VK_STATE_BIND_POINT_STENCIL: return (void*)&dynamicStencilStateMap[handle]; default: @@ -421,10 +421,10 @@ 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_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_WRITE_ENABLE, CBSTATUS_DEPTH_BOUND, CBSTATUS_DEPTH_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_NOT_BOUND, "Depth object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_LINE_WIDTH_BOUND, CBSTATUS_LINE_WIDTH_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_LINE_WIDTH_NOT_BOUND, "Line width object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_DEPTH_BIAS_BOUND, CBSTATUS_DEPTH_BIAS_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BIAS_NOT_BOUND, "Depth bias object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_BLEND_BOUND, CBSTATUS_BLEND_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_BLEND_NOT_BOUND, "Blend object not bound to this command buffer"); + result &= validate_status(pCB, CBSTATUS_DEPTH_WRITE_ENABLE, CBSTATUS_DEPTH_BOUNDS_BOUND, CBSTATUS_DEPTH_BOUNDS_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BOUNDS_NOT_BOUND, "Depth bounds object not bound to this command buffer"); result &= validate_status(pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_BOUND, CBSTATUS_STENCIL_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Stencil object not bound to this command buffer"); if (indexedDraw) result &= validate_status(pCB, CBSTATUS_NONE, CBSTATUS_INDEX_BUFFER_BOUND, CBSTATUS_INDEX_BUFFER_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_INDEX_BUFFER_NOT_BOUND, "Index buffer object not bound to this command buffer when Index Draw attempted"); @@ -1153,14 +1153,14 @@ 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_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) { - pNode->status |= CBSTATUS_DEPTH_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_LINE_WIDTH) { + pNode->status |= CBSTATUS_LINE_WIDTH_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH_BIAS) { + pNode->status |= CBSTATUS_DEPTH_BIAS_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_BLEND) { + pNode->status |= CBSTATUS_BLEND_BOUND; + } else if (stateBindPoint == VK_STATE_BIND_POINT_DEPTH_BOUNDS) { + pNode->status |= CBSTATUS_DEPTH_BOUNDS_BOUND; } else if (stateBindPoint == VK_STATE_BIND_POINT_STENCIL) { pNode->status |= CBSTATUS_STENCIL_BOUND; } @@ -1627,30 +1627,30 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, Vk return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicLineWidthState(device, dynamicLineWidthState); // TODO : Clean up any internal data structures using this obj. return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState); // TODO : Clean up any internal data structures using this obj. return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicColorBlendState(device, dynamicColorBlendState); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicBlendState(device, dynamicBlendState); // TODO : Clean up any internal data structures using this obj. return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthState(VkDevice device, VkDynamicDepthState dynamicDepthState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthState(device, dynamicDepthState); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState); // TODO : Clean up any internal data structures using this obj. return result; } @@ -1987,42 +1987,42 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, con return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicLineWidthState(VkDevice device, const VkDynamicLineWidthStateCreateInfo* pCreateInfo, VkDynamicLineWidthState* 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); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicLineWidthState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_LINE_WIDTH); loader_platform_thread_lock_mutex(&globalLock); - dynamicRasterLineStateMap[pState->handle] = *pCreateInfo; + dynamicLineWidthStateMap[pState->handle] = *pCreateInfo; loader_platform_thread_unlock_mutex(&globalLock); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthBiasState(VkDevice device, const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, VkDynamicDepthBiasState* pState) { - 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); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicDepthBiasState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH_BIAS); loader_platform_thread_lock_mutex(&globalLock); - dynamicRasterDepthBiasStateMap[pState->handle] = *pCreateInfo; + dynamicDepthBiasStateMap[pState->handle] = *pCreateInfo; loader_platform_thread_unlock_mutex(&globalLock); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicBlendState(VkDevice device, const VkDynamicBlendStateCreateInfo* pCreateInfo, VkDynamicBlendState* pState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicColorBlendState(device, pCreateInfo, pState); - //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_COLOR_BLEND); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicBlendState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_BLEND); loader_platform_thread_lock_mutex(&globalLock); - dynamicCbStateMap[pState->handle] = *pCreateInfo; + dynamicBlendStateMap[pState->handle] = *pCreateInfo; loader_platform_thread_unlock_mutex(&globalLock); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthState(VkDevice device, const VkDynamicDepthStateCreateInfo* pCreateInfo, VkDynamicDepthState* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthBoundsState(VkDevice device, const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, VkDynamicDepthBoundsState* pState) { - VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicDepthState(device, pCreateInfo, pState); - //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH); + VkResult result = get_dispatch_table(draw_state_device_table_map, device)->CreateDynamicDepthBoundsState(device, pCreateInfo, pState); + //insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_POINT_DEPTH_BOUNDS); loader_platform_thread_lock_mutex(&globalLock); - dynamicDepthStateMap[pState->handle] = *pCreateInfo; + dynamicDepthBoundsStateMap[pState->handle] = *pCreateInfo; loader_platform_thread_unlock_mutex(&globalLock); return result; } @@ -2187,111 +2187,111 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, } } } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState dynamicRasterLineState) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicLineWidthState(VkCmdBuffer cmdBuffer, VkDynamicLineWidthState dynamicLineWidthState) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { if (pCB->state == CB_UPDATE_ACTIVE) { updateCBTracking(cmdBuffer); - addCmd(pCB, CMD_BINDDYNAMICRASTERLINESTATE); + addCmd(pCB, CMD_BINDDYNAMICLINEWIDTHSTATE); 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."); + "Incorrect call to vkCmdBindDynamicLineWidthState() 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); + pCB->status |= CBSTATUS_LINE_WIDTH_BOUND; + if (dynamicLineWidthStateMap.find(dynamicLineWidthState.handle) == dynamicLineWidthStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE, dynamicLineWidthState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicLineWidthState object %#" PRIxLEAST64 ", was it ever created?", dynamicLineWidthState.handle); } else { - pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle; - g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle; + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_LINE_WIDTH] = dynamicLineWidthState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_LINE_WIDTH] = dynamicLineWidthState.handle; } loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicLineWidthState(cmdBuffer, dynamicLineWidthState); } else { - report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterLineState()"); + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicLineWidthState()"); } } } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicDepthBiasState dynamicDepthBiasState) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { if (pCB->state == CB_UPDATE_ACTIVE) { updateCBTracking(cmdBuffer); - addCmd(pCB, CMD_BINDDYNAMICRASTERDEPTHBIASSTATE); + addCmd(pCB, CMD_BINDDYNAMICDEPTHBIASSTATE); 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 vkCmdBindDynamicRasterDepthBiasState() without an active RenderPass."); + "Incorrect call to vkCmdBindDynamicDepthBiasState() without an active RenderPass."); } loader_platform_thread_lock_mutex(&globalLock); - 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); + pCB->status |= CBSTATUS_DEPTH_BIAS_BOUND; + if (dynamicDepthBiasStateMap.find(dynamicDepthBiasState.handle) == dynamicDepthBiasStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE, dynamicDepthBiasState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicDepthBiasState object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthBiasState.handle); } else { - pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle; - g_lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle; + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BIAS] = dynamicDepthBiasState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BIAS] = dynamicDepthBiasState.handle; } loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicDepthBiasState(cmdBuffer, dynamicDepthBiasState); } else { - report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicRasterDepthBiasState()"); + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicDepthBiasState()"); } } } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicBlendState(VkCmdBuffer cmdBuffer, VkDynamicBlendState dynamicBlendState) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { if (pCB->state == CB_UPDATE_ACTIVE) { updateCBTracking(cmdBuffer); - addCmd(pCB, CMD_BINDDYNAMICCOLORBLENDSTATE); + addCmd(pCB, CMD_BINDDYNAMICBLENDSTATE); 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 vkCmdBindDynamicColorBlendState() without an active RenderPass."); + "Incorrect call to vkCmdBindDynamicBlendState() without an active RenderPass."); } loader_platform_thread_lock_mutex(&globalLock); - pCB->status |= CBSTATUS_COLOR_BLEND_BOUND; - if (dynamicCbStateMap.find(dynamicColorBlendState.handle) == dynamicCbStateMap.end()) { - log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE, dynamicColorBlendState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", - "Unable to find VkDynamicColorBlendState object %#" PRIxLEAST64 ", was it ever created?", dynamicColorBlendState.handle); + pCB->status |= CBSTATUS_BLEND_BOUND; + if (dynamicBlendStateMap.find(dynamicBlendState.handle) == dynamicBlendStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE, dynamicBlendState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicBlendState object %#" PRIxLEAST64 ", was it ever created?", dynamicBlendState.handle); } else { - pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_COLOR_BLEND] = dynamicColorBlendState.handle; - g_lastBoundDynamicState[VK_STATE_BIND_POINT_COLOR_BLEND] = dynamicColorBlendState.handle; + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_BLEND] = dynamicBlendState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_BLEND] = dynamicBlendState.handle; } loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicBlendState(cmdBuffer, dynamicBlendState); } else { - report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicColorBlendState()"); + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicBlendState()"); } } } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthState(VkCmdBuffer cmdBuffer, VkDynamicDepthState dynamicDepthState) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthBoundsState(VkCmdBuffer cmdBuffer, VkDynamicDepthBoundsState dynamicDepthBoundsState) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { if (pCB->state == CB_UPDATE_ACTIVE) { updateCBTracking(cmdBuffer); - addCmd(pCB, CMD_BINDDYNAMICDEPTHSTATE); + addCmd(pCB, CMD_BINDDYNAMICDEPTHBOUNDSSTATE); 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 vkCmdBindDynamicDepthState() without an active RenderPass."); + "Incorrect call to vkCmdBindDynamicDepthBoundsState() without an active RenderPass."); } loader_platform_thread_lock_mutex(&globalLock); - pCB->status |= CBSTATUS_DEPTH_BOUND; - if (dynamicDepthStateMap.find(dynamicDepthState.handle) == dynamicDepthStateMap.end()) { - log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE, dynamicDepthState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", - "Unable to find VkDynamicDepthState object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthState.handle); + pCB->status |= CBSTATUS_DEPTH_BOUNDS_BOUND; + if (dynamicDepthBoundsStateMap.find(dynamicDepthBoundsState.handle) == dynamicDepthBoundsStateMap.end()) { + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE, dynamicDepthBoundsState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS", + "Unable to find VkDynamicDepthBoundsState object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthBoundsState.handle); } else { - pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH] = dynamicDepthState.handle; - g_lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH] = dynamicDepthState.handle; + pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BOUNDS] = dynamicDepthBoundsState.handle; + g_lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BOUNDS] = dynamicDepthBoundsState.handle; } loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicDepthState(cmdBuffer, dynamicDepthState); + get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBindDynamicDepthBoundsState(cmdBuffer, dynamicDepthBoundsState); } else { - report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicDepthState()"); + report_error_no_cb_begin(cmdBuffer, "vkCmdBindDynamicDepthBoundsState()"); } } } @@ -3177,14 +3177,14 @@ 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, "vkDestroyDynamicRasterLineState")) - return (PFN_vkVoidFunction) vkDestroyDynamicRasterLineState; - if (!strcmp(funcName, "vkDestroyDynamicRasterDepthBiasState")) - return (PFN_vkVoidFunction) vkDestroyDynamicRasterDepthBiasState; - if (!strcmp(funcName, "vkDestroyDynamicColorBlendState")) - return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState; - if (!strcmp(funcName, "vkDestroyDynamicDepthState")) - return (PFN_vkVoidFunction) vkDestroyDynamicDepthState; + if (!strcmp(funcName, "vkDestroyDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkDestroyDynamicLineWidthState; + if (!strcmp(funcName, "vkDestroyDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkDestroyDynamicDepthBiasState; + if (!strcmp(funcName, "vkDestroyDynamicBlendState")) + return (PFN_vkVoidFunction) vkDestroyDynamicBlendState; + if (!strcmp(funcName, "vkDestroyDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkDestroyDynamicDepthBoundsState; if (!strcmp(funcName, "vkDestroyDynamicStencilState")) return (PFN_vkVoidFunction) vkDestroyDynamicStencilState; if (!strcmp(funcName, "vkDestroyCommandBuffer")) @@ -3227,14 +3227,14 @@ 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, "vkCreateDynamicRasterLineState")) - return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState; - if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState")) - return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState; - if (!strcmp(funcName, "vkCreateDynamicColorBlendState")) - return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState; - if (!strcmp(funcName, "vkCreateDynamicDepthState")) - return (PFN_vkVoidFunction) vkCreateDynamicDepthState; + if (!strcmp(funcName, "vkCreateDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkCreateDynamicLineWidthState; + if (!strcmp(funcName, "vkCreateDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkCreateDynamicDepthBiasState; + if (!strcmp(funcName, "vkCreateDynamicBlendState")) + return (PFN_vkVoidFunction) vkCreateDynamicBlendState; + if (!strcmp(funcName, "vkCreateDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkCreateDynamicDepthBoundsState; if (!strcmp(funcName, "vkCreateDynamicStencilState")) return (PFN_vkVoidFunction) vkCreateDynamicStencilState; if (!strcmp(funcName, "vkCreateCommandBuffer")) @@ -3249,14 +3249,14 @@ 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, "vkCmdBindDynamicRasterLineState")) - return (PFN_vkVoidFunction) vkCmdBindDynamicRasterLineState; - if (!strcmp(funcName, "vkCmdBindDynamicRasterDepthBiasState")) - return (PFN_vkVoidFunction) vkCmdBindDynamicRasterDepthBiasState; - if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState")) - return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState; - if (!strcmp(funcName, "vkCmdBindDynamicDepthState")) - return (PFN_vkVoidFunction) vkCmdBindDynamicDepthState; + if (!strcmp(funcName, "vkCmdBindDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicLineWidthState; + if (!strcmp(funcName, "vkCmdBindDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicDepthBiasState; + if (!strcmp(funcName, "vkCmdBindDynamicBlendState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicBlendState; + if (!strcmp(funcName, "vkCmdBindDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicDepthBoundsState; if (!strcmp(funcName, "vkCmdBindDynamicStencilState")) return (PFN_vkVoidFunction) vkCmdBindDynamicStencilState; if (!strcmp(funcName, "vkCmdBindDescriptorSets")) diff --git a/layers/draw_state.h b/layers/draw_state.h index fe4b03d..f326c20 100644 --- a/layers/draw_state.h +++ b/layers/draw_state.h @@ -52,10 +52,10 @@ 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_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_NOT_BOUND, // Draw submitted with no depth state object bound when depth enabled + DRAWSTATE_LINE_WIDTH_NOT_BOUND, // Draw submitted with no line width state object bound + DRAWSTATE_DEPTH_BIAS_NOT_BOUND, // Draw submitted with no depth bias state object bound + DRAWSTATE_BLEND_NOT_BOUND, // Draw submitted with no blend state object bound when color write enabled + DRAWSTATE_DEPTH_BOUNDS_NOT_BOUND, // Draw submitted with no depth bounds state object bound when depth enabled DRAWSTATE_STENCIL_NOT_BOUND, // Draw submitted with no stencil state object bound when stencil enabled DRAWSTATE_INDEX_BUFFER_NOT_BOUND, // Draw submitted with no depth-stencil state object bound when depth write enabled DRAWSTATE_PIPELINE_LAYOUT_MISMATCH, // Draw submitted PSO Pipeline layout that doesn't match layout from BindDescriptorSets @@ -166,10 +166,10 @@ typedef enum _CMD_TYPE CMD_BINDPIPELINE, CMD_BINDPIPELINEDELTA, CMD_BINDDYNAMICVIEWPORTSTATE, - CMD_BINDDYNAMICRASTERLINESTATE, - CMD_BINDDYNAMICRASTERDEPTHBIASSTATE, - CMD_BINDDYNAMICCOLORBLENDSTATE, - CMD_BINDDYNAMICDEPTHSTATE, + CMD_BINDDYNAMICLINEWIDTHSTATE, + CMD_BINDDYNAMICDEPTHBIASSTATE, + CMD_BINDDYNAMICBLENDSTATE, + CMD_BINDDYNAMICDEPTHBOUNDSSTATE, CMD_BINDDYNAMICSTENCILSTATE, CMD_BINDDESCRIPTORSETS, CMD_BINDINDEXBUFFER, @@ -229,13 +229,13 @@ typedef enum _CBStatusFlagBits { CBSTATUS_NONE = 0x00000000, // No status is set CBSTATUS_VIEWPORT_BOUND = 0x00000001, // Viewport state object 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_LINE_WIDTH_BOUND = 0x00000002, // Line width state object has been bound + CBSTATUS_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_BLEND_BOUND = 0x00000010, // Blend state object has been bound CBSTATUS_DEPTH_WRITE_ENABLE = 0x00000020, // PSO w/ Depth Enable set has been bound CBSTATUS_STENCIL_TEST_ENABLE = 0x00000040, // PSO w/ Stencil Enable set has been bound - CBSTATUS_DEPTH_BOUND = 0x00000080, // Depth state object has been bound + CBSTATUS_DEPTH_BOUNDS_BOUND = 0x00000080, // Depth bounds state object has been bound CBSTATUS_STENCIL_BOUND = 0x00000100, // Stencil state object has been bound CBSTATUS_INDEX_BUFFER_BOUND = 0x00000200, // Index buffer has been bound } CBStatusFlagBits; diff --git a/layers/layer_common.h b/layers/layer_common.h index f457905..b5ce825 100644 --- a/layers/layer_common.h +++ b/layers/layer_common.h @@ -26,10 +26,10 @@ typedef enum _DYNAMIC_STATE_BIND_POINT { VK_STATE_BIND_POINT_VIEWPORT, - VK_STATE_BIND_POINT_RASTER_LINE, - VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS, - VK_STATE_BIND_POINT_COLOR_BLEND, - VK_STATE_BIND_POINT_DEPTH, + VK_STATE_BIND_POINT_LINE_WIDTH, + VK_STATE_BIND_POINT_DEPTH_BIAS, + VK_STATE_BIND_POINT_BLEND, + VK_STATE_BIND_POINT_DEPTH_BOUNDS, VK_STATE_BIND_POINT_STENCIL, VK_NUM_STATE_BIND_POINT // Used for array sizing } DYNAMIC_STATE_BIND_POINT; @@ -40,14 +40,14 @@ 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_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: - return "DEPTH"; + case VK_STATE_BIND_POINT_LINE_WIDTH: + return "LINE_WIDTH"; + case VK_STATE_BIND_POINT_DEPTH_BIAS: + return "DEPTH_BIAS"; + case VK_STATE_BIND_POINT_BLEND: + return "BLEND"; + case VK_STATE_BIND_POINT_DEPTH_BOUNDS: + return "DEPTH_BOUNDS"; case VK_STATE_BIND_POINT_STENCIL: return "STENCIL"; default: @@ -61,14 +61,14 @@ 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_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: - return VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE; + case VK_STATE_BIND_POINT_LINE_WIDTH: + return VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE; + case VK_STATE_BIND_POINT_DEPTH_BIAS: + return VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE; + case VK_STATE_BIND_POINT_BLEND: + return VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE; + case VK_STATE_BIND_POINT_DEPTH_BOUNDS: + return VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE; case VK_STATE_BIND_POINT_STENCIL: return VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE; default: diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index f7bc3a5..a91c974 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -95,10 +95,10 @@ unordered_map renderPassMap; unordered_map framebufferMap; //unordered_map descriptorSetMap; unordered_map dynamicViewportStateMap; -unordered_map dynamicRasterLineStateMap; -unordered_map dynamicRasterDepthBiasStateMap; -unordered_map dynamicColorBlendStateMap; -unordered_map dynamicDepthStateMap; +unordered_map dynamicLineWidthStateMap; +unordered_map dynamicDepthBiasStateMap; +unordered_map dynamicBlendStateMap; +unordered_map dynamicDepthBoundsStateMap; unordered_map dynamicStencilStateMap; // For a given handle and object type, return a ptr to its CreateInfo struct, or NULL if not found @@ -226,31 +226,31 @@ static void* get_object_create_info(uint64_t handle, VkDbgObjectType type) return (void*)&(*it).second; break; } - case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE: + case VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE: { - auto it = dynamicRasterLineStateMap.find(handle); - if (it != dynamicRasterLineStateMap.end()) + auto it = dynamicLineWidthStateMap.find(handle); + if (it != dynamicLineWidthStateMap.end()) return (void*)&(*it).second; break; } - case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE: + case VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE: { - auto it = dynamicRasterDepthBiasStateMap.find(handle); - if (it != dynamicRasterDepthBiasStateMap.end()) + auto it = dynamicDepthBiasStateMap.find(handle); + if (it != dynamicDepthBiasStateMap.end()) return (void*)&(*it).second; break; } - case VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE: + case VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE: { - auto it = dynamicColorBlendStateMap.find(handle); - if (it != dynamicColorBlendStateMap.end()) + auto it = dynamicBlendStateMap.find(handle); + if (it != dynamicBlendStateMap.end()) return (void*)&(*it).second; break; } - case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE: + case VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE: { - auto it = dynamicDepthStateMap.find(handle); - if (it != dynamicDepthStateMap.end()) + auto it = dynamicDepthBoundsStateMap.find(handle); + if (it != dynamicDepthBoundsStateMap.end()) return (void*)&(*it).second; break; } @@ -527,28 +527,28 @@ static void add_object_create_info(const uint64_t handle, const VkDbgObjectType memcpy(pCI, pCreateInfo, sizeof(VkDynamicViewportStateCreateInfo)); break; } - case VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE: + case VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE: { - auto pCI = &dynamicRasterLineStateMap[handle]; - memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterLineStateCreateInfo)); + auto pCI = &dynamicLineWidthStateMap[handle]; + memcpy(pCI, pCreateInfo, sizeof(VkDynamicLineWidthStateCreateInfo)); break; } - case VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE: + case VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE: { - auto pCI = &dynamicRasterDepthBiasStateMap[handle]; - memcpy(pCI, pCreateInfo, sizeof(VkDynamicRasterDepthBiasStateCreateInfo)); + auto pCI = &dynamicDepthBiasStateMap[handle]; + memcpy(pCI, pCreateInfo, sizeof(VkDynamicDepthBiasStateCreateInfo)); break; } - case VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE: + case VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE: { - auto pCI = &dynamicColorBlendStateMap[handle]; - memcpy(pCI, pCreateInfo, sizeof(VkDynamicColorBlendStateCreateInfo)); + auto pCI = &dynamicBlendStateMap[handle]; + memcpy(pCI, pCreateInfo, sizeof(VkDynamicBlendStateCreateInfo)); break; } - case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE: + case VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE: { - auto pCI = &dynamicDepthStateMap[handle]; - memcpy(pCI, pCreateInfo, sizeof(VkDynamicDepthStateCreateInfo)); + auto pCI = &dynamicDepthBoundsStateMap[handle]; + memcpy(pCI, pCreateInfo, sizeof(VkDynamicDepthBoundsStateCreateInfo)); break; } case VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE: @@ -1164,10 +1164,10 @@ 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, 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, dynamicDepthStateMap, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE, "DynamicDepthState"); + print_object_map_members(dispObj, dynamicLineWidthStateMap, VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE, "DynamicLineWidthState"); + print_object_map_members(dispObj, dynamicDepthBiasStateMap, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE, "DynamicDepthBiasState"); + print_object_map_members(dispObj, dynamicBlendStateMap, VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE, "DynamicBlendState"); + print_object_map_members(dispObj, dynamicDepthBoundsStateMap, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE, "DynamicDepthBoundsState"); print_object_map_members(dispObj, dynamicStencilStateMap, VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE, "DynamicStencilState"); log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, 0, 0, MEMTRACK_NONE, "MEM", "*** End of Object lists ***"); } @@ -1852,51 +1852,51 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, Vk return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState) { loader_platform_thread_lock_mutex(&globalLock); - auto item = dynamicRasterLineStateMap.find(dynamicRasterLineState.handle); - if (item != dynamicRasterLineStateMap.end()) { - dynamicRasterLineStateMap.erase(item); + auto item = dynamicLineWidthStateMap.find(dynamicLineWidthState.handle); + if (item != dynamicLineWidthStateMap.end()) { + dynamicLineWidthStateMap.erase(item); } loader_platform_thread_unlock_mutex(&globalLock); - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicLineWidthState(device, dynamicLineWidthState); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState) { loader_platform_thread_lock_mutex(&globalLock); - auto item = dynamicRasterDepthBiasStateMap.find(dynamicRasterDepthBiasState.handle); - if (item != dynamicRasterDepthBiasStateMap.end()) { - dynamicRasterDepthBiasStateMap.erase(item); + auto item = dynamicDepthBiasStateMap.find(dynamicDepthBiasState.handle); + if (item != dynamicDepthBiasStateMap.end()) { + dynamicDepthBiasStateMap.erase(item); } loader_platform_thread_unlock_mutex(&globalLock); - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState) { loader_platform_thread_lock_mutex(&globalLock); - auto item = dynamicColorBlendStateMap.find(dynamicColorBlendState.handle); - if (item != dynamicColorBlendStateMap.end()) { - dynamicColorBlendStateMap.erase(item); + auto item = dynamicBlendStateMap.find(dynamicBlendState.handle); + if (item != dynamicBlendStateMap.end()) { + dynamicBlendStateMap.erase(item); } loader_platform_thread_unlock_mutex(&globalLock); - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicColorBlendState(device, dynamicColorBlendState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicBlendState(device, dynamicBlendState); return result; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthState(VkDevice device, VkDynamicDepthState dynamicDepthState) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState) { loader_platform_thread_lock_mutex(&globalLock); - auto item = dynamicDepthStateMap.find(dynamicDepthState.handle); - if (item != dynamicDepthStateMap.end()) { - dynamicDepthStateMap.erase(item); + auto item = dynamicDepthBoundsStateMap.find(dynamicDepthBoundsState.handle); + if (item != dynamicDepthBoundsStateMap.end()) { + dynamicDepthBoundsStateMap.erase(item); } loader_platform_thread_unlock_mutex(&globalLock); - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicDepthState(device, dynamicDepthState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState); return result; } @@ -2338,57 +2338,57 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState( return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicLineWidthState( VkDevice device, - const VkDynamicRasterLineStateCreateInfo *pCreateInfo, - VkDynamicRasterLineState *pState) + const VkDynamicLineWidthStateCreateInfo *pCreateInfo, + VkDynamicLineWidthState *pState) { - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicLineWidthState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_LINE_STATE, pCreateInfo); + add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE, pCreateInfo); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthBiasState( VkDevice device, - const VkDynamicRasterDepthBiasStateCreateInfo *pCreateInfo, - VkDynamicRasterDepthBiasState *pState) + const VkDynamicDepthBiasStateCreateInfo *pCreateInfo, + VkDynamicDepthBiasState *pState) { - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicDepthBiasState(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); + add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE, pCreateInfo); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicBlendState( VkDevice device, - const VkDynamicColorBlendStateCreateInfo *pCreateInfo, - VkDynamicColorBlendState *pState) + const VkDynamicBlendStateCreateInfo *pCreateInfo, + VkDynamicBlendState *pState) { - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicBlendState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE, pCreateInfo); + add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE, pCreateInfo); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthBoundsState( VkDevice device, - const VkDynamicDepthStateCreateInfo *pCreateInfo, - VkDynamicDepthState *pState) + const VkDynamicDepthBoundsStateCreateInfo *pCreateInfo, + VkDynamicDepthBoundsState *pState) { - VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicDepthState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicDepthBoundsState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE, pCreateInfo); + add_object_create_info(pState->handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE, pCreateInfo); loader_platform_thread_unlock_mutex(&globalLock); } return result; @@ -2523,11 +2523,11 @@ void VKAPI vkCmdBindDynamicViewportState( get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); } -void VKAPI vkCmdBindDynamicRasterLineState( +void VKAPI vkCmdBindDynamicLineWidthState( VkCmdBuffer cmdBuffer, - VkDynamicRasterLineState dynamicRasterLineState) + VkDynamicLineWidthState dynamicLineWidthState) { - VkDynamicRasterLineStateCreateInfo* pCI; + VkDynamicLineWidthStateCreateInfo* pCI; loader_platform_thread_lock_mutex(&globalLock); MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer); if (!pCmdBuf) { @@ -2535,21 +2535,21 @@ void VKAPI vkCmdBindDynamicRasterLineState( 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); + pCI = (VkDynamicLineWidthStateCreateInfo*)get_object_create_info(dynamicLineWidthState.handle, VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_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); + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE, dynamicLineWidthState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", + "Unable to find dynamic line width state object %#" PRIxLEAST64 ", was it ever created?", dynamicLineWidthState.handle); } - pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_LINE] = dynamicRasterLineState.handle; + pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_LINE_WIDTH] = dynamicLineWidthState.handle; loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState); + get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicLineWidthState(cmdBuffer, dynamicLineWidthState); } -void VKAPI vkCmdBindDynamicRasterDepthBiasState( +void VKAPI vkCmdBindDynamicDepthBiasState( VkCmdBuffer cmdBuffer, - VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) + VkDynamicDepthBiasState dynamicDepthBiasState) { - VkDynamicRasterDepthBiasStateCreateInfo* pCI; + VkDynamicDepthBiasStateCreateInfo* pCI; loader_platform_thread_lock_mutex(&globalLock); MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer); if (!pCmdBuf) { @@ -2557,21 +2557,21 @@ void VKAPI vkCmdBindDynamicRasterDepthBiasState( 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 = (VkDynamicRasterDepthBiasStateCreateInfo*)get_object_create_info(dynamicRasterDepthBiasState.handle, VK_OBJECT_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE); + pCI = (VkDynamicDepthBiasStateCreateInfo*)get_object_create_info(dynamicDepthBiasState.handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE); if (!pCI) { - 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); + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE, dynamicDepthBiasState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", + "Unable to find dynamic depth bias state object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthBiasState.handle); } - pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_RASTER_DEPTH_BIAS] = dynamicRasterDepthBiasState.handle; + pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BIAS] = dynamicDepthBiasState.handle; loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState); + get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicDepthBiasState(cmdBuffer, dynamicDepthBiasState); } -void VKAPI vkCmdBindDynamicColorBlendState( +void VKAPI vkCmdBindDynamicBlendState( VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState) + VkDynamicBlendState dynamicBlendState) { - VkDynamicColorBlendStateCreateInfo* pCI; + VkDynamicBlendStateCreateInfo* pCI; loader_platform_thread_lock_mutex(&globalLock); MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer); if (!pCmdBuf) { @@ -2579,21 +2579,21 @@ void VKAPI vkCmdBindDynamicColorBlendState( 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 = (VkDynamicColorBlendStateCreateInfo*)get_object_create_info(dynamicColorBlendState.handle, VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE); + pCI = (VkDynamicBlendStateCreateInfo*)get_object_create_info(dynamicBlendState.handle, VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE); if (!pCI) { - log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE, dynamicColorBlendState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", - "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicColorBlendState.handle); + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE, dynamicBlendState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", + "Unable to find dynamic blend state object %#" PRIxLEAST64 ", was it ever created?", dynamicBlendState.handle); } - pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_COLOR_BLEND] = dynamicColorBlendState.handle; + pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_BLEND] = dynamicBlendState.handle; loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); + get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicBlendState(cmdBuffer, dynamicBlendState); } -void VKAPI vkCmdBindDynamicDepthState( +void VKAPI vkCmdBindDynamicDepthBoundsState( VkCmdBuffer cmdBuffer, - VkDynamicDepthState dynamicDepthState) + VkDynamicDepthBoundsState dynamicDepthBoundsState) { - VkDynamicDepthStateCreateInfo* pCI; + VkDynamicDepthBoundsStateCreateInfo* pCI; loader_platform_thread_lock_mutex(&globalLock); MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer); if (!pCmdBuf) { @@ -2601,14 +2601,14 @@ void VKAPI vkCmdBindDynamicDepthState( 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 = (VkDynamicDepthStateCreateInfo*)get_object_create_info(dynamicDepthState.handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE); + pCI = (VkDynamicDepthBoundsStateCreateInfo*)get_object_create_info(dynamicDepthBoundsState.handle, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE); if (!pCI) { - log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE, dynamicDepthState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", - "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthState.handle); + log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE, dynamicDepthBoundsState.handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", + "Unable to find dynamic raster state object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthBoundsState.handle); } - pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH] = dynamicDepthState.handle; + pCmdBuf->pLastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_BOUNDS] = dynamicDepthBoundsState.handle; loader_platform_thread_unlock_mutex(&globalLock); - get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicDepthState(cmdBuffer, dynamicDepthState); + get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicDepthBoundsState(cmdBuffer, dynamicDepthBoundsState); } void VKAPI vkCmdBindDynamicStencilState( @@ -3200,14 +3200,14 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( return (PFN_vkVoidFunction) vkDestroyFramebuffer; if (!strcmp(funcName, "vkDestroyDynamicViewportState")) return (PFN_vkVoidFunction) vkDestroyDynamicViewportState; - 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, "vkDestroyDynamicDepthState")) - return (PFN_vkVoidFunction) vkDestroyDynamicDepthState; + if (!strcmp(funcName, "vkDestroyDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkDestroyDynamicLineWidthState; + if (!strcmp(funcName, "vkDestroyDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkDestroyDynamicDepthBiasState; + if (!strcmp(funcName, "vkDestroyDynamicBlendState")) + return (PFN_vkVoidFunction) vkDestroyDynamicBlendState; + if (!strcmp(funcName, "vkDestroyDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkDestroyDynamicDepthBoundsState; if (!strcmp(funcName, "vkDestroyDynamicStencilState")) return (PFN_vkVoidFunction) vkDestroyDynamicStencilState; if (!strcmp(funcName, "vkBindBufferMemory")) @@ -3260,14 +3260,14 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( return (PFN_vkVoidFunction) vkCreateSampler; if (!strcmp(funcName, "vkCreateDynamicViewportState")) return (PFN_vkVoidFunction) vkCreateDynamicViewportState; - 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, "vkCreateDynamicDepthState")) - return (PFN_vkVoidFunction) vkCreateDynamicDepthState; + if (!strcmp(funcName, "vkCreateDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkCreateDynamicLineWidthState; + if (!strcmp(funcName, "vkCreateDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkCreateDynamicDepthBiasState; + if (!strcmp(funcName, "vkCreateDynamicBlendState")) + return (PFN_vkVoidFunction) vkCreateDynamicBlendState; + if (!strcmp(funcName, "vkCreateDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkCreateDynamicDepthBoundsState; if (!strcmp(funcName, "vkCreateDynamicStencilState")) return (PFN_vkVoidFunction) vkCreateDynamicStencilState; if (!strcmp(funcName, "vkCreateCommandBuffer")) @@ -3282,14 +3282,14 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( return (PFN_vkVoidFunction) vkCmdBindPipeline; if (!strcmp(funcName, "vkCmdBindDynamicViewportState")) return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState; - 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, "vkCmdBindDynamicDepthState")) - return (PFN_vkVoidFunction) vkCmdBindDynamicDepthState; + if (!strcmp(funcName, "vkCmdBindDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicLineWidthState; + if (!strcmp(funcName, "vkCmdBindDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicDepthBiasState; + if (!strcmp(funcName, "vkCmdBindDynamicBlendState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicBlendState; + if (!strcmp(funcName, "vkCmdBindDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkCmdBindDynamicDepthBoundsState; if (!strcmp(funcName, "vkCmdBindDynamicStencilState")) return (PFN_vkVoidFunction) vkCmdBindDynamicStencilState; if (!strcmp(funcName, "vkCmdBindDescriptorSets")) diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp index 91e1c31..3faff8d 100644 --- a/layers/param_checker.cpp +++ b/layers/param_checker.cpp @@ -5843,16 +5843,16 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState( return result; } -bool PreCreateDynamicRasterLineState( +bool PreCreateDynamicLineWidthState( VkDevice device, - const VkDynamicRasterLineStateCreateInfo* pCreateInfo) + const VkDynamicLineWidthStateCreateInfo* pCreateInfo) { if(pCreateInfo != nullptr) { - if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_LINE_STATE_CREATE_INFO) + if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_LINE_WIDTH_STATE_CREATE_INFO) { log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", - "vkCreateDynamicRasterLineState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); + "vkCreateDynamicLineWidthState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } } @@ -5860,9 +5860,9 @@ bool PreCreateDynamicRasterLineState( return true; } -bool PostCreateDynamicRasterLineState( +bool PostCreateDynamicLineWidthState( VkDevice device, - VkDynamicRasterLineState* pState, + VkDynamicLineWidthState* pState, VkResult result) { @@ -5872,7 +5872,7 @@ bool PostCreateDynamicRasterLineState( if(result < VK_SUCCESS) { - std::string reason = "vkCreateDynamicRasterLineState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkCreateDynamicLineWidthState 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 PostCreateDynamicRasterLineState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicLineWidthState( VkDevice device, - const VkDynamicRasterLineStateCreateInfo* pCreateInfo, - VkDynamicRasterLineState* pState) + const VkDynamicLineWidthStateCreateInfo* pCreateInfo, + VkDynamicLineWidthState* pState) { - PreCreateDynamicRasterLineState(device, pCreateInfo); + PreCreateDynamicLineWidthState(device, pCreateInfo); - VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterLineState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicLineWidthState(device, pCreateInfo, pState); - PostCreateDynamicRasterLineState(device, pState, result); + PostCreateDynamicLineWidthState(device, pState, result); return result; } -bool PostDestroyDynamicRasterLineState( +bool PostDestroyDynamicLineWidthState( VkDevice device, - VkDynamicRasterLineState dynamicRasterLineState, + VkDynamicLineWidthState dynamicLineWidthState, VkResult result) { if(result < VK_SUCCESS) { - std::string reason = "vkDestroyDynamicRasterLineState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkDestroyDynamicLineWidthState 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,27 +5911,27 @@ bool PostDestroyDynamicRasterLineState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState( +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthState( VkDevice device, - VkDynamicRasterLineState dynamicRasterLineState) + VkDynamicLineWidthState dynamicLineWidthState) { - VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterLineState(device, dynamicRasterLineState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicLineWidthState(device, dynamicLineWidthState); - PostDestroyDynamicRasterLineState(device, dynamicRasterLineState, result); + PostDestroyDynamicLineWidthState(device, dynamicLineWidthState, result); return result; } -bool PreCreateDynamicRasterDepthBiasState( +bool PreCreateDynamicDepthBiasState( VkDevice device, - const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo) + const VkDynamicDepthBiasStateCreateInfo* pCreateInfo) { if(pCreateInfo != nullptr) { - if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_RASTER_DEPTH_BIAS_STATE_CREATE_INFO) + if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_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"); + "vkCreateDynamicDepthBiasState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } } @@ -5939,9 +5939,9 @@ bool PreCreateDynamicRasterDepthBiasState( return true; } -bool PostCreateDynamicRasterDepthBiasState( +bool PostCreateDynamicDepthBiasState( VkDevice device, - VkDynamicRasterDepthBiasState* pState, + VkDynamicDepthBiasState* pState, VkResult result) { @@ -5951,7 +5951,7 @@ bool PostCreateDynamicRasterDepthBiasState( if(result < VK_SUCCESS) { - std::string reason = "vkCreateDynamicRasterDepthBiasState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkCreateDynamicDepthBiasState 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; } @@ -5959,30 +5959,30 @@ bool PostCreateDynamicRasterDepthBiasState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthBiasState( VkDevice device, - const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, - VkDynamicRasterDepthBiasState* pState) + const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, + VkDynamicDepthBiasState* pState) { - PreCreateDynamicRasterDepthBiasState(device, pCreateInfo); + PreCreateDynamicDepthBiasState(device, pCreateInfo); - VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicDepthBiasState(device, pCreateInfo, pState); - PostCreateDynamicRasterDepthBiasState(device, pState, result); + PostCreateDynamicDepthBiasState(device, pState, result); return result; } -bool PostDestroyDynamicRasterDepthBiasState( +bool PostDestroyDynamicDepthBiasState( VkDevice device, - VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState, + VkDynamicDepthBiasState dynamicDepthBiasState, VkResult result) { if(result < VK_SUCCESS) { - std::string reason = "vkDestroyDynamicRasterDepthBiasState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkDestroyDynamicDepthBiasState 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; } @@ -5990,27 +5990,27 @@ bool PostDestroyDynamicRasterDepthBiasState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState( +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState( VkDevice device, - VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) + VkDynamicDepthBiasState dynamicDepthBiasState) { - VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState); - PostDestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState, result); + PostDestroyDynamicDepthBiasState(device, dynamicDepthBiasState, result); return result; } -bool PreCreateDynamicColorBlendState( +bool PreCreateDynamicBlendState( VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo) + const VkDynamicBlendStateCreateInfo* pCreateInfo) { if(pCreateInfo != nullptr) { - if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO) + if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_BLEND_STATE_CREATE_INFO) { log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", - "vkCreateDynamicColorBlendState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); + "vkCreateDynamicBlendState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } } @@ -6018,9 +6018,9 @@ bool PreCreateDynamicColorBlendState( return true; } -bool PostCreateDynamicColorBlendState( +bool PostCreateDynamicBlendState( VkDevice device, - VkDynamicColorBlendState* pState, + VkDynamicBlendState* pState, VkResult result) { @@ -6030,7 +6030,7 @@ bool PostCreateDynamicColorBlendState( if(result < VK_SUCCESS) { - std::string reason = "vkCreateDynamicColorBlendState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkCreateDynamicBlendState 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; } @@ -6038,30 +6038,30 @@ bool PostCreateDynamicColorBlendState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicBlendState( VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState) + const VkDynamicBlendStateCreateInfo* pCreateInfo, + VkDynamicBlendState* pState) { - PreCreateDynamicColorBlendState(device, pCreateInfo); + PreCreateDynamicBlendState(device, pCreateInfo); - VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicBlendState(device, pCreateInfo, pState); - PostCreateDynamicColorBlendState(device, pState, result); + PostCreateDynamicBlendState(device, pState, result); return result; } -bool PostDestroyDynamicColorBlendState( +bool PostDestroyDynamicBlendState( VkDevice device, - VkDynamicColorBlendState dynamicColorBlendState, + VkDynamicBlendState dynamicBlendState, VkResult result) { if(result < VK_SUCCESS) { - std::string reason = "vkDestroyDynamicColorBlendState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkDestroyDynamicBlendState 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; } @@ -6069,27 +6069,27 @@ bool PostDestroyDynamicColorBlendState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState( +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicBlendState( VkDevice device, - VkDynamicColorBlendState dynamicColorBlendState) + VkDynamicBlendState dynamicBlendState) { - VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicColorBlendState(device, dynamicColorBlendState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicBlendState(device, dynamicBlendState); - PostDestroyDynamicColorBlendState(device, dynamicColorBlendState, result); + PostDestroyDynamicBlendState(device, dynamicBlendState, result); return result; } -bool PreCreateDynamicDepthState( +bool PreCreateDynamicDepthBoundsState( VkDevice device, - const VkDynamicDepthStateCreateInfo* pCreateInfo) + const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo) { if(pCreateInfo != nullptr) { - if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STATE_CREATE_INFO) + if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE_CREATE_INFO) { log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", - "vkCreateDynamicDepthState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); + "vkCreateDynamicDepthBoundsState parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } } @@ -6097,9 +6097,9 @@ bool PreCreateDynamicDepthState( return true; } -bool PostCreateDynamicDepthState( +bool PostCreateDynamicDepthBoundsState( VkDevice device, - VkDynamicDepthState* pState, + VkDynamicDepthBoundsState* pState, VkResult result) { @@ -6109,7 +6109,7 @@ bool PostCreateDynamicDepthState( if(result < VK_SUCCESS) { - std::string reason = "vkCreateDynamicDepthState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkCreateDynamicDepthBoundsState 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; } @@ -6117,28 +6117,28 @@ bool PostCreateDynamicDepthState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthState( +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthBoundsState( VkDevice device, - const VkDynamicDepthStateCreateInfo* pCreateInfo, - VkDynamicDepthState* pState) + const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, + VkDynamicDepthBoundsState* pState) { - PreCreateDynamicDepthState(device, pCreateInfo); + PreCreateDynamicDepthBoundsState(device, pCreateInfo); - VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicDepthState(device, pCreateInfo, pState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDynamicDepthBoundsState(device, pCreateInfo, pState); - PostCreateDynamicDepthState(device, pState, result); + PostCreateDynamicDepthBoundsState(device, pState, result); return result; } -bool PostDestroyDynamicDepthState( +bool PostDestroyDynamicDepthBoundsState( VkDevice device, - VkDynamicDepthState dynamicDepthState, + VkDynamicDepthBoundsState dynamicDepthBoundsState, VkResult result) { if(result < VK_SUCCESS) { - std::string reason = "vkDestroyDynamicDepthState parameter, VkResult result, is " + EnumeratorString(result); + std::string reason = "vkDestroyDynamicDepthBoundsState 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; } @@ -6146,13 +6146,13 @@ bool PostDestroyDynamicDepthState( return true; } -VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthState( +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState( VkDevice device, - VkDynamicDepthState dynamicDepthState) + VkDynamicDepthBoundsState dynamicDepthBoundsState) { - VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicDepthState(device, dynamicDepthState); + VkResult result = get_dispatch_table(pc_device_table_map, device)->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState); - PostDestroyDynamicDepthState(device, dynamicDepthState, result); + PostDestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState, result); return result; } @@ -6911,74 +6911,74 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicViewportState( PostCmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); } -bool PostCmdBindDynamicRasterLineState( +bool PostCmdBindDynamicLineWidthState( VkCmdBuffer cmdBuffer, - VkDynamicRasterLineState dynamicRasterLineState) + VkDynamicLineWidthState dynamicLineWidthState) { return true; } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState( +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicLineWidthState( VkCmdBuffer cmdBuffer, - VkDynamicRasterLineState dynamicRasterLineState) + VkDynamicLineWidthState dynamicLineWidthState) { - get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState); + get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicLineWidthState(cmdBuffer, dynamicLineWidthState); - PostCmdBindDynamicRasterLineState(cmdBuffer, dynamicRasterLineState); + PostCmdBindDynamicLineWidthState(cmdBuffer, dynamicLineWidthState); } -bool PostCmdBindDynamicRasterDepthBiasState( +bool PostCmdBindDynamicDepthBiasState( VkCmdBuffer cmdBuffer, - VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) + VkDynamicDepthBiasState dynamicDepthBiasState) { return true; } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState( +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthBiasState( VkCmdBuffer cmdBuffer, - VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) + VkDynamicDepthBiasState dynamicDepthBiasState) { - get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState); + get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicDepthBiasState(cmdBuffer, dynamicDepthBiasState); - PostCmdBindDynamicRasterDepthBiasState(cmdBuffer, dynamicRasterDepthBiasState); + PostCmdBindDynamicDepthBiasState(cmdBuffer, dynamicDepthBiasState); } -bool PostCmdBindDynamicColorBlendState( +bool PostCmdBindDynamicBlendState( VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState) + VkDynamicBlendState dynamicBlendState) { return true; } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState( +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicBlendState( VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState) + VkDynamicBlendState dynamicBlendState) { - get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); + get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicBlendState(cmdBuffer, dynamicBlendState); - PostCmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); + PostCmdBindDynamicBlendState(cmdBuffer, dynamicBlendState); } -bool PostCmdBindDynamicDepthState( +bool PostCmdBindDynamicDepthBoundsState( VkCmdBuffer cmdBuffer, - VkDynamicDepthState dynamicDepthState) + VkDynamicDepthBoundsState dynamicDepthBoundsState) { return true; } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthState( +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthBoundsState( VkCmdBuffer cmdBuffer, - VkDynamicDepthState dynamicDepthState) + VkDynamicDepthBoundsState dynamicDepthBoundsState) { - get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicDepthState(cmdBuffer, dynamicDepthState); + get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDynamicDepthBoundsState(cmdBuffer, dynamicDepthBoundsState); - PostCmdBindDynamicDepthState(cmdBuffer, dynamicDepthState); + PostCmdBindDynamicDepthBoundsState(cmdBuffer, dynamicDepthBoundsState); } bool PostCmdBindDynamicStencilState( @@ -8460,14 +8460,14 @@ 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, "vkCreateDynamicRasterLineState")) - return (PFN_vkVoidFunction) vkCreateDynamicRasterLineState; - if (!strcmp(funcName, "vkCreateDynamicRasterDepthBiasState")) - return (PFN_vkVoidFunction) vkCreateDynamicRasterDepthBiasState; - if (!strcmp(funcName, "vkCreateDynamicColorBlendState")) - return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState; - if (!strcmp(funcName, "vkCreateDynamicDepthState")) - return (PFN_vkVoidFunction) vkCreateDynamicDepthState; + if (!strcmp(funcName, "vkCreateDynamicLineWidthState")) + return (PFN_vkVoidFunction) vkCreateDynamicLineWidthState; + if (!strcmp(funcName, "vkCreateDynamicDepthBiasState")) + return (PFN_vkVoidFunction) vkCreateDynamicDepthBiasState; + if (!strcmp(funcName, "vkCreateDynamicBlendState")) + return (PFN_vkVoidFunction) vkCreateDynamicBlendState; + if (!strcmp(funcName, "vkCreateDynamicDepthBoundsState")) + return (PFN_vkVoidFunction) vkCreateDynamicDepthBoundsState; if (!strcmp(funcName, "vkCreateDynamicStencilState")) return (PFN_vkVoidFunction) vkCreateDynamicStencilState; if (!strcmp(funcName, "vkCreateCommandBuffer")) diff --git a/layers/vk_validation_layer_details.md b/layers/vk_validation_layer_details.md index 53f989b..8b045f6 100644 --- a/layers/vk_validation_layer_details.md +++ b/layers/vk_validation_layer_details.md @@ -21,11 +21,11 @@ The DrawState layer tracks state leading into Draw cmds. This includes the Pipel | Valid DescriptorSetLayout | Flag DescriptorSetLayout object that was not properly created | INVALID_LAYOUT | vkAllocDescriptorSets | None | Anywhere else to check this? | | Valid Pipeline | Flag VkPipeline object that was not properly created | INVALID_PIPELINE | vkCmdBindPipeline | InvalidPipeline | NA | | Valid Pipeline Create Info | Tests for the following: That compute shaders are not specified for the graphics pipeline, tess evaluation and tess control shaders are included or excluded as a pair, that VK_PRIMITIVE_TOPOLOGY_PATCH is set as IA topology for tessellation pipelines, that VK_PRIMITIVE_TOPOLOGY_PATCH primitive topology is only set for tessellation pipelines, and that Vtx Shader specified | INVALID_PIPELINE_CREATE_STATE | vkCreateGraphicsPipeline | InvalidPipelineCreateState | NA | -| Valid CmdBuffer | Validates that the command buffer object was properly created and is currently valid | INVALID_CMD_BUFFER | vkQueueSubmit vkBeginCommandBuffer vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd vkCreateCommandBuffer | None | NA | -| Valid Dynamic State | Validates that each of the 4 DSOs are valid, properly constructed objects of the correct type | INVALID_DYNAMIC_STATE_OBJECT | vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState | None | NA | +| Valid CmdBuffer | Validates that the command buffer object was properly created and is currently valid | INVALID_CMD_BUFFER | vkQueueSubmit vkBeginCommandBuffer vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicLineWidthState vkCmdBindDynamicDepthBiasState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthBoundsState vkCmdBindDynamicStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd vkCreateCommandBuffer | None | NA | +| Valid Dynamic State | Validates that each of the 4 DSOs are valid, properly constructed objects of the correct type | INVALID_DYNAMIC_STATE_OBJECT | vkCmdBindDynamicViewportState vkCmdBindDynamicLineWidthState vkCmdBindDynamicDepthBiasState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthBoundsState vkCmdBindDynamicStencilState | None | NA | | Vtx Buffer Bounds | Check if VBO index too large for PSO Vtx binding count, and that at least one vertex buffer is attached to pipeline object | VTX_INDEX_OUT_OF_BOUNDS | vkCmdBindDescriptorSets vkCmdBindVertexBuffers | VtxBufferBadIndex | NA | | Cmd Buffer End | Verifies that EndCommandBuffer was called for this cmdBuffer at QueueSubmit time | NO_END_CMD_BUFFER | vkQueueSubmit | NoEndCmdBuffer | NA | -| Cmd Buffer Begin | Check that BeginCommandBuffer was called for this command buffer when binding commands or calling end | NO_BEGIN_CMD_BUFFER | vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp | NoBeginCmdBuffer | NA | +| Cmd Buffer Begin | Check that BeginCommandBuffer was called for this command buffer when binding commands or calling end | NO_BEGIN_CMD_BUFFER | vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicLineWidthState vkCmdBindDynamicDepthBiasState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthBoundsState vkCmdBindDynamicStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp | NoBeginCmdBuffer | NA | | Cmd Buffer Submit Count | Verify that ONE_TIME submit cmdbuffer is not submitted multiple times | DRAWSTATE_CMD_BUFFER_SINGLE_SUBMIT_VIOLATION | vkBeginCommandBuffer, vkQueueSubmit | CmdBufferTwoSubmits | NA | | DS Pool End Update | Flag if DS Pool end update called w/o a begin | DS_END_WITHOUT_BEGIN | vkEndDescriptorPoolUpdate | DSEndWithoutBegin | NA | | DS Pool Update | Flag if DS Update called w/o a begin | UPDATE_WITHOUT_BEGIN | vkEndDescriptorPoolUpdate | DSUpdateWithoutBegin | NA | @@ -37,7 +37,7 @@ The DrawState layer tracks state leading into Draw cmds. This includes the Pipel | MSAA Sample Count | Verifies that Pipeline, RenderPass, and Subpass sample counts are consistent | NUM_SAMPLES_MISMATCH | vkCmdBindPipeline vkCmdBeginRenderPass vkCmdNextSubpass | NumSamplesMismatch | NA | | Dynamic State Binding | Verify that viewport and raster dynamic states are bound to Cmd Buffer at Draw time, and if color or depth are enabled, verify that their respective states are also bound | VIEWPORT_NOT_BOUND, RASTER_NOT_BOUND, COLOR_NOT_BOUND, DEPTH_NOT_BOUND |vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect | RasterStateNotBound, ViewportStateNotBound, ColorBlendStateNotBound, DepthStencilStateNotBound | Write targeted test | | RenderPass misuse | Tests for the following: that BeginRenderPass, ResolveImage, ClearColorImage, ClearDepthStencilImage are not called during an active Renderpass, and that binding compute descriptior sets or pipelines does not take place during an active | INVALID_RENDERPASS_CMD | vkCmdBindPipeline() w/ COMPUTE vkCmdBindDescriptorSets() w/ COMPUTE vkCmdBlitImage vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdBeginRenderPass | RenderPassWithinRenderPass | NA | -| Correct use of RenderPass | Validates that rendering commands are issued inside an active RenderPass | NO_ACTIVE_RENDERPASS | vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect | BindPipelineNoRenderPass, VtxBufferNoRenderPass | NA | +| Correct use of RenderPass | Validates that rendering commands are issued inside an active RenderPass | NO_ACTIVE_RENDERPASS | vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicLineWidthState vkCmdBindDynamicDepthBiasState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthBoundsState vkCmdBindDynamicStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect | BindPipelineNoRenderPass, VtxBufferNoRenderPass | NA | | Valid RenderPass | Flag error if attempt made to Begin/End/Continue a NULL or otherwise invalid RenderPass object | INVALID_RENDERPASS | vkCmdBeginRenderPass, vkCmdEndRenderPass, vkBeginCommandBuffer | NullRenderPass | NA | | DescriptorSet Updated | Warn user if DescriptorSet bound that was never updated | DESCRIPTOR_SET_NOT_UPDATED | vkCmdBindDescriptorSets() | DescriptorSetNotUpdated | NA | | Correct Clear Use | Warn user if CmdClear for Color or DepthStencil issued to Cmd Buffer prior to a Draw Cmd. RenderPass LOAD_OP_CLEAR is preferred in this case. | CLEAR_CMD_BEFORE_DRAW | vkCmdClearColorImage(), vkCmdClearDepthStencil() | ClearCmdNoDraw | NA | @@ -79,8 +79,8 @@ The ParamChecker layer validates parameter values and flags errors for any value | Check | Overview | ENUM | Relevant API | Testname | Notes/TODO | | ----- | -------- | ---------------- | ------------ | -------- | ---------- | -| Input Parameters | Pointers in structures are recursively validated to be non-null. Enumerated types are validated against min and max enum values. Structure Types are verified to be correct. | NA | vkQueueSubmit vkAllocMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkCreateFence vkResetFences vkWaitForFences vkCreateSemaphore vkCreateEvent vkCreateQueryPool vkCreateBuffer vkCreateBufferView vkCreateImage vkGetImageSubresourceLayout vkCreateImageView vkCreateAttachmentView vkCreateShader vkCreatePipelineCache vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkCreatePipelineLayout vkCreateSampler vkCreateDescriptorSetLayout( vkCreateDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateDynamicViewportState vkCreateDynamicRasterState vkCreateDynamicColorBlendState vkCreateDynamicDepthStencilState vkCreateFramebuffer vkCreateRenderPass vkCreateCommandPool vkCreateCommandBuffer vkBeginCommandBuffer vkCmdBindDescriptorSets vkCmdBindVertexBuffers vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdResolveImage vkCmdWaitEvents vkCmdPipelineBarrier vkCmdPushConstants vkCmdBeginRenderPass vkCmdExecuteCommands | TBD | NA | -| Call results, Output Parameters | Return values are checked for VK_SUCCESS, returned pointers are checked to be NON-NULL, enumerated types of return values are checked to be within the defined range. | NA | vkEnumeratePhysicalDevices vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceLimits vkGetPhysicalDeviceProperties vkGetPhysicalDeviceQueueCount vkGetPhysicalDeviceQueueProperties vkGetPhysicalDeviceMemoryProperties vkGetDeviceQueue vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle vkAllocMemory vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkGetDeviceMemoryCommitment vkBindBufferMemory vkBindImageMemory vkGetBufferMemoryRequirements vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetPhysicalDeviceSparseImageFormatProperties vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkCreateFence vkDestroyFence vkResetFences vkGetFenceStatus vkWaitForFences vkCreateSemaphore vkDestroySemaphore vkQueueSignalSemaphore vkQueueWaitSemaphore vkCreateEvent vkDestroyEvent vkGetEventStatus vkSetEvent vkResetEvent vkCreateQueryPool vkDestroyQueryPool vkGetQueryPoolResults vkCreateBuffer vkDestroyBuffer vkCreateBufferView vkDestroyBufferView vkCreateImage vkDestroyImage vkGetImageSubresourceLayout vkCreateImageView vkDestroyImageView vkCreateAttachmentView vkDestroyAttachmentView vkDestroyShaderModule vkCreateShader vkDestroyShader vkCreatePipelineCache vkDestroyPipelineCache vkGetPipelineCacheSize vkGetPipelineCacheData vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkDestroyPipeline vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateSampler vkDestroySampler vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateDynamicViewportState vkDestroyDynamicViewportState vkCreateDynamicRasterState vkDestroyDynamicRasterState vkCreateDynamicColorBlendState vkDestroyDynamicColorBlendState vkCreateDynamicDepthStencilState vkDestroyDynamicDepthStencilState vkCreateFramebuffer vkDestroyFramebuffer vkCreateRenderPass vkDestroyRenderPass vkGetRenderAreaGranularity vkCreateCommandPool vkDestroyCommandPool vkResetCommandPool vkCreateCommandBuffer vkDestroyCommandBuffer vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdPushConstants vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands | TBD | NA | +| Input Parameters | Pointers in structures are recursively validated to be non-null. Enumerated types are validated against min and max enum values. Structure Types are verified to be correct. | NA | vkQueueSubmit vkAllocMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkCreateFence vkResetFences vkWaitForFences vkCreateSemaphore vkCreateEvent vkCreateQueryPool vkCreateBuffer vkCreateBufferView vkCreateImage vkGetImageSubresourceLayout vkCreateImageView vkCreateAttachmentView vkCreateShader vkCreatePipelineCache vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkCreatePipelineLayout vkCreateSampler vkCreateDescriptorSetLayout( vkCreateDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateDynamicViewportState vkCreateDynamicLineWidthState vkCreateDynamicDepthBiasState vkCreateDynamicBlendState vkCreateDynamicDepthBoundsState vkCreateDynamicStencilState vkCreateFramebuffer vkCreateRenderPass vkCreateCommandPool vkCreateCommandBuffer vkBeginCommandBuffer vkCmdBindDescriptorSets vkCmdBindVertexBuffers vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdResolveImage vkCmdWaitEvents vkCmdPipelineBarrier vkCmdPushConstants vkCmdBeginRenderPass vkCmdExecuteCommands | TBD | NA | +| Call results, Output Parameters | Return values are checked for VK_SUCCESS, returned pointers are checked to be NON-NULL, enumerated types of return values are checked to be within the defined range. | NA | vkEnumeratePhysicalDevices vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceLimits vkGetPhysicalDeviceProperties vkGetPhysicalDeviceQueueCount vkGetPhysicalDeviceQueueProperties vkGetPhysicalDeviceMemoryProperties vkGetDeviceQueue vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle vkAllocMemory vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkGetDeviceMemoryCommitment vkBindBufferMemory vkBindImageMemory vkGetBufferMemoryRequirements vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetPhysicalDeviceSparseImageFormatProperties vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkCreateFence vkDestroyFence vkResetFences vkGetFenceStatus vkWaitForFences vkCreateSemaphore vkDestroySemaphore vkQueueSignalSemaphore vkQueueWaitSemaphore vkCreateEvent vkDestroyEvent vkGetEventStatus vkSetEvent vkResetEvent vkCreateQueryPool vkDestroyQueryPool vkGetQueryPoolResults vkCreateBuffer vkDestroyBuffer vkCreateBufferView vkDestroyBufferView vkCreateImage vkDestroyImage vkGetImageSubresourceLayout vkCreateImageView vkDestroyImageView vkCreateAttachmentView vkDestroyAttachmentView vkDestroyShaderModule vkCreateShader vkDestroyShader vkCreatePipelineCache vkDestroyPipelineCache vkGetPipelineCacheSize vkGetPipelineCacheData vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkDestroyPipeline vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateSampler vkDestroySampler vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateDynamicViewportState vkDestroyDynamicViewportState vkCreateDynamicLineWidthState vkDestroyDynamicLineWidthState vkCreateDynamicDepthBiasState vkDestroyDynamicDepthBiasState vkCreateDynamicBlendState vkDestroyDynamicBlendState vkCreateDynamicDepthBiasState vkDestroyDynamicDepthBiasState vkCreateDynamicStencilState vkDestroyDynamicStencilState vkCreateFramebuffer vkDestroyFramebuffer vkCreateRenderPass vkDestroyRenderPass vkGetRenderAreaGranularity vkCreateCommandPool vkDestroyCommandPool vkResetCommandPool vkCreateCommandBuffer vkDestroyCommandBuffer vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdPushConstants vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands | TBD | NA | ### ParamChecker Pending Work Additional work to be done @@ -120,11 +120,11 @@ The MemTracker layer tracks memory objects and references and validates that the | Check | Overview | ENUM MEMTRACK_* | Relevant API | Testname | Notes/TODO | | ----- | -------- | ---------------- | ------------ | -------- | ---------- | -| Valid Command Buffer | Verifies that the command buffer was properly created and is currently valid | INVALID_CB | vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState vkBeginCommandBuffer vkResetCommandBuffer vkDestroyDevice vkFreeMemory | NA | NA | +| Valid Command Buffer | Verifies that the command buffer was properly created and is currently valid | INVALID_CB | vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicLineWidthState vkCmdBindDynamicDepthBiasState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthBoundsState vkCmdBindDynamicStencilState vkBeginCommandBuffer vkResetCommandBuffer vkDestroyDevice vkFreeMemory | NA | NA | | Valid Memory Object | Verifies that the memory object was properly created and is currently valid | INVALID_MEM_OBJ | vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkFreeMemory vkBindBufferMemory vkBindImageMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkQueueBindSparseBufferMemory | NA | NA | | Free Referenced Memory | Checks to see if memory being freed still has current references | FREED_MEM_REF | vmFreeMemory | FreeBoundMemory | NA | | Memory Properly Bound | Validate that the memory object referenced in the call was properly created, is currently valid, and is properly bound to the object | MISSING_MEM_BINDINGS | vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage | NA | NA | -| Valid Object | Verifies that the specified Vulkan object was created properly and is currently valid | INVALID_OBJECT | vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage | NA | NA | +| Valid Object | Verifies that the specified Vulkan object was created properly and is currently valid | INVALID_OBJECT | vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicLineWidthState vkCmdBindDynamicDepthBiasState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthBoundsState vkCmdBindDynamicStencilState vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage | NA | NA | | Bind Invalid Memory | Validate that memory object was correctly created, that the command buffer object was correctly created, and that both are currently valid objects. | MEMORY_BINDING_ERROR | vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkQueueBindSparseBufferMemory vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage | BindInvalidMemory BindMemoryToDestroyedObject | This is probably redundant, as these checks are performed at a lower level. | | Objects Not Destroyed | Verify all objects destroyed at DestroyDevice time | MEMORY_LEAK | vkDestroyDevice | NA | NA | | Memory Mapping State | Verifies that mapped memory is CPU-visible | INVALID_STATE | vkMapMemory | MapMemWithoutHostVisibleBit | NA | @@ -189,13 +189,13 @@ The ObjectTracker layer maintains a record of all Vulkan objects. It flags error | Check | Overview | ENUM OBJTRACK_* | Relevant API | Testname | Notes/TODO | | ----- | -------- | ---------------- | ------------ | -------- | ---------- | -| Valid Object | Validates that referenced object was properly created and is currently valid. | UNKNOWN_OBJECT | vkAcquireNextImageWSI vkAllocDescriptorSets vkAllocMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDynamicRasterState vkCmdBindDynamicViewportState vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearColorAttachment vkCmdClearColorImage vkCmdClearDepthStencilAttachment vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateAttachmentView vkCreateBuffer vkCreateBufferView vkCreateCommandBuffer vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateDynamicColorBlendState vkCreateDynamicDepthStencilState vkCreateDynamicRasterState vkCreateDynamicViewportState vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapChainWSI vkDestroyAttachmentView vkDestroyBuffer vkDestroyBufferView vkDestroyCommandBuffer vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyDynamicColorBlendState vkDestroyDynamicDepthStencilState vkDestroyDynamicRasterState vkDestroyDynamicViewportState vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapChainWSI vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportWSI vkGetPipelineCacheData vkGetPipelineCacheSize vkGetQueryPoolResults vkGetRenderAreaGranularity vkGetSurfaceInfoWSI vkGetSwapChainInfoWSI vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparseBufferMemory vkQueueSignalSemaphore vkQueueWaitSemaphore vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | ? | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT | +| Valid Object | Validates that referenced object was properly created and is currently valid. | UNKNOWN_OBJECT | vkAcquireNextImageWSI vkAllocDescriptorSets vkAllocMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindDynamicViewportState vkCmdBindDynamicLineWidthState vkCmdBindDynamicDepthBiasState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthBoundsState vkCmdBindDynamicStencilState vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearColorAttachment vkCmdClearColorImage vkCmdClearDepthStencilAttachment vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateAttachmentView vkCreateBuffer vkCreateBufferView vkCreateCommandBuffer vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateDynamicViewportState vkCreateDynamicLineWidthState vkCreateDynamicDepthBiasState vkCreateDynamicBlendState vkCreateDynamicDepthBoundsState vkCreateDynamicStencilState vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapChainWSI vkDestroyAttachmentView vkDestroyBuffer vkDestroyBufferView vkDestroyCommandBuffer vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyDynamicBlendState vkDestroyDynamicDepthStencilState vkDestroyDynamicRasterState vkDestroyDynamicViewportState vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapChainWSI vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportWSI vkGetPipelineCacheData vkGetPipelineCacheSize vkGetQueryPoolResults vkGetRenderAreaGranularity vkGetSurfaceInfoWSI vkGetSwapChainInfoWSI vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparseBufferMemory vkQueueSignalSemaphore vkQueueWaitSemaphore vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | ? | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT | | Object Cleanup | Verify that object properly destroyed | DESTROY_OBJECT_FAILED | vkDestroyInstance, vkDestroyDevice, vkFreeMemory, vkDestroyObject | ? | NA | | Object Type | Verify generic VkObject if of expected VkObjectType | OBJECT_TYPE_MISMATCH | vkDestroyObject, vkGetObjectInfo | GetObjectInfoMismatchedType | NA | | Objects Leak | When an Instance or Device object is destroyed, validates that all objects belonging to that device/instance have previously been destroyed | OBJECT_LEAK | vkDestroyDevice vk DestroyInstance | ? | NA | | Object Count | Flag error if number of objects requested from extenstion functions exceeds max number of actual objects | OBJCOUNT_MAX_EXCEEDED | objTrackGetObjects, objTrackGetObjectsOfType | ? | NA | | Valid Fence for Wait | Flag error if waiting on unsubmitted fence object | INVALID_FENCE | vkGetFenceStatus | WaitForUnsubmittedFence | NA | -| Valid Destroy Object | Validates that an object pass into a destroy function was properly created and is currently valid | NONE | vkDestroyInstance vkDestroyDevice vkDestroyFence vkDestroySemaphore vkDestroyEvent vkDestroyQueryPool vkDestroyBuffer vkDestroyBufferView vkDestroyImage vkDestroyImageView vkDestroyAttachmentView vkDestroyShaderModule vkDestroyShader vkDestroyPipelineCache vkDestroyPipeline vkDestroyPipelineLayout vkDestroySampler vkDestroyDescriptorSetLayout vkDestroyDescriptorPool vkDestroyDynamicViewportState vkDestroyDynamicRasterState vkDestroyDynamicColorBlendState vkDestroyDynamicDepthStencilState vkDestroyCommandPool vkDestroyCommandBuffer vkDestroyFramebuffer vkDestroyRenderPass vkDestroySwapChainWSI | TBD | These cases need to be moved to a more appropriate error enum | +| Valid Destroy Object | Validates that an object pass into a destroy function was properly created and is currently valid | NONE | vkDestroyInstance vkDestroyDevice vkDestroyFence vkDestroySemaphore vkDestroyEvent vkDestroyQueryPool vkDestroyBuffer vkDestroyBufferView vkDestroyImage vkDestroyImageView vkDestroyAttachmentView vkDestroyShaderModule vkDestroyShader vkDestroyPipelineCache vkDestroyPipeline vkDestroyPipelineLayout vkDestroySampler vkDestroyDescriptorSetLayout vkDestroyDescriptorPool vkDestroyDynamicViewportState vkDestroyDynamicRasterState vkDestroyDynamicBlendState vkDestroyDynamicDepthStencilState vkDestroyCommandPool vkDestroyCommandBuffer vkDestroyFramebuffer vkDestroyRenderPass vkDestroySwapChainWSI | TBD | These cases need to be moved to a more appropriate error enum | ### ObjectTracker Pending Work @@ -231,8 +231,8 @@ It cannot insure that there is no latent race condition. | Check | Overview | ENUM THREADING_CHECKER_* | Relevant API | | ----- | -------- | ---------------- | ---------------- | -| Thread Collision | Detects and notifies user if multiple threads are modifying thes same object | MULTIPLE_THREADS | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkDestroySemaphore vkQueueSignalSemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkDestroyCommandBuffer vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | -| Thread Reentrancy | Detects cases of a single thread calling Vulkan reentrantly | SINGLE_THREAD_REUSE | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkDestroySemaphore vkQueueSignalSemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkDestroyCommandBuffer vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicColorBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | +| Thread Collision | Detects and notifies user if multiple threads are modifying thes same object | MULTIPLE_THREADS | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkDestroySemaphore vkQueueSignalSemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkDestroyCommandBuffer vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | +| Thread Reentrancy | Detects cases of a single thread calling Vulkan reentrantly | SINGLE_THREAD_REUSE | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkDestroySemaphore vkQueueSignalSemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkDestroyCommandBuffer vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDynamicViewportState vkCmdBindDynamicRasterState vkCmdBindDynamicBlendState vkCmdBindDynamicDepthStencilState vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearColorAttachment vkCmdClearDepthStencilAttachment vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ### Threading Pending Work Additional work to be done @@ -258,4 +258,4 @@ APIDump layer is used for dumping a stream of all the Vulkan API calls that are ### APIDump Pending Work - 1. vkAllocDescriptorSets does not correctly print out all of the created DescriptorSets (no array printing following main API txt) \ No newline at end of file + 1. vkAllocDescriptorSets does not correctly print out all of the created DescriptorSets (no array printing following main API txt) diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h index 185a140..f1b2886 100644 --- a/loader/gpa_helper.h +++ b/loader/gpa_helper.h @@ -215,22 +215,22 @@ static inline void* globalGetProcAddr(const char *name) return (void*) vkCreateDynamicViewportState; if (!strcmp(name, "DestroyDynamicViewportState")) return (void*) vkDestroyDynamicViewportState; - 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")) - return (void*) vkDestroyDynamicColorBlendState; - if (!strcmp(name, "CreateDynamicDepthState")) - return (void*) vkCreateDynamicDepthState; - if (!strcmp(name, "DestroyDynamicDepthState")) - return (void*) vkDestroyDynamicDepthState; + if (!strcmp(name, "CreateDynamicLineWidthState")) + return (void*) vkCreateDynamicLineWidthState; + if (!strcmp(name, "DestroyDynamicLineWidthState")) + return (void*) vkDestroyDynamicLineWidthState; + if (!strcmp(name, "CreateDynamicDepthBiasState")) + return (void*) vkCreateDynamicDepthBiasState; + if (!strcmp(name, "DestroyDynamicDepthBiasState")) + return (void*) vkDestroyDynamicDepthBiasState; + if (!strcmp(name, "CreateDynamicBlendState")) + return (void*) vkCreateDynamicBlendState; + if (!strcmp(name, "DestroyDynamicBlendState")) + return (void*) vkDestroyDynamicBlendState; + if (!strcmp(name, "CreateDynamicDepthBoundsState")) + return (void*) vkCreateDynamicDepthBoundsState; + if (!strcmp(name, "DestroyDynamicDepthBoundsState")) + return (void*) vkDestroyDynamicDepthBoundsState; if (!strcmp(name, "CreateDynamicStencilState")) return (void*) vkCreateDynamicStencilState; if (!strcmp(name, "DestroyDynamicStencilState")) @@ -265,14 +265,14 @@ static inline void* globalGetProcAddr(const char *name) return (void*) vkCmdBindPipeline; if (!strcmp(name, "CmdBindDynamicViewportState")) return (void*) vkCmdBindDynamicViewportState; - if (!strcmp(name, "CmdBindDynamicRasterLineState")) - return (void*) vkCmdBindDynamicRasterLineState; - if (!strcmp(name, "CmdBindDynamicRasterDepthBiasState")) - return (void*) vkCmdBindDynamicRasterDepthBiasState; - if (!strcmp(name, "CmdBindDynamicColorBlendState")) - return (void*) vkCmdBindDynamicColorBlendState; - if (!strcmp(name, "CmdBindDynamicDepthState")) - return (void*) vkCmdBindDynamicDepthState; + if (!strcmp(name, "CmdBindDynamicLineWidthState")) + return (void*) vkCmdBindDynamicLineWidthState; + if (!strcmp(name, "CmdBindDynamicDepthBiasState")) + return (void*) vkCmdBindDynamicDepthBiasState; + if (!strcmp(name, "CmdBindDynamicBlendState")) + return (void*) vkCmdBindDynamicBlendState; + if (!strcmp(name, "CmdBindDynamicDepthBoundsState")) + return (void*) vkCmdBindDynamicDepthBoundsState; if (!strcmp(name, "CmdBindDynamicStencilState")) return (void*) vkCmdBindDynamicStencilState; if (!strcmp(name, "CmdBindDescriptorSets")) diff --git a/loader/table_ops.h b/loader/table_ops.h index d1a59d5..49f01e4 100644 --- a/loader/table_ops.h +++ b/loader/table_ops.h @@ -112,14 +112,14 @@ 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->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->CreateDynamicDepthState = (PFN_vkCreateDynamicDepthState) gpa(dev, "vkCreateDynamicDepthState"); - table->DestroyDynamicDepthState = (PFN_vkDestroyDynamicDepthState) gpa(dev, "vkDestroyDynamicDepthState"); + table->CreateDynamicLineWidthState = (PFN_vkCreateDynamicLineWidthState) gpa(dev, "vkCreateDynamicLineWidthState"); + table->DestroyDynamicLineWidthState = (PFN_vkDestroyDynamicLineWidthState) gpa(dev, "vkDestroyDynamicLineWidthState"); + table->CreateDynamicDepthBiasState = (PFN_vkCreateDynamicDepthBiasState) gpa(dev, "vkCreateDynamicDepthBiasState"); + table->DestroyDynamicDepthBiasState = (PFN_vkDestroyDynamicDepthBiasState) gpa(dev, "vkDestroyDynamicDepthBiasState"); + table->CreateDynamicBlendState = (PFN_vkCreateDynamicBlendState) gpa(dev, "vkCreateDynamicBlendState"); + table->DestroyDynamicBlendState = (PFN_vkDestroyDynamicBlendState) gpa(dev, "vkDestroyDynamicBlendState"); + table->CreateDynamicDepthBoundsState = (PFN_vkCreateDynamicDepthBoundsState) gpa(dev, "vkCreateDynamicDepthBoundsState"); + table->DestroyDynamicDepthBoundsState = (PFN_vkDestroyDynamicDepthBoundsState) gpa(dev, "vkDestroyDynamicDepthBoundsState"); table->CreateDynamicStencilState = (PFN_vkCreateDynamicStencilState) gpa(dev, "vkCreateDynamicStencilState"); table->DestroyDynamicStencilState = (PFN_vkDestroyDynamicStencilState) gpa(dev, "vkDestroyDynamicStencilState"); table->CreateFramebuffer = (PFN_vkCreateFramebuffer) gpa(dev, "vkCreateFramebuffer"); @@ -137,10 +137,10 @@ 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->CmdBindDynamicRasterLineState = (PFN_vkCmdBindDynamicRasterLineState) gpa(dev, "vkCmdBindDynamicRasterLineState"); - table->CmdBindDynamicRasterDepthBiasState = (PFN_vkCmdBindDynamicRasterDepthBiasState) gpa(dev, "vkCmdBindDynamicRasterDepthBiasState"); - table->CmdBindDynamicColorBlendState = (PFN_vkCmdBindDynamicColorBlendState) gpa(dev, "vkCmdBindDynamicColorBlendState"); - table->CmdBindDynamicDepthState = (PFN_vkCmdBindDynamicDepthState) gpa(dev, "vkCmdBindDynamicDepthState"); + table->CmdBindDynamicLineWidthState = (PFN_vkCmdBindDynamicLineWidthState) gpa(dev, "vkCmdBindDynamicLineWidthState"); + table->CmdBindDynamicDepthBiasState = (PFN_vkCmdBindDynamicDepthBiasState) gpa(dev, "vkCmdBindDynamicDepthBiasState"); + table->CmdBindDynamicBlendState = (PFN_vkCmdBindDynamicBlendState) gpa(dev, "vkCmdBindDynamicBlendState"); + table->CmdBindDynamicDepthBoundsState = (PFN_vkCmdBindDynamicDepthBoundsState) gpa(dev, "vkCmdBindDynamicDepthBoundsState"); table->CmdBindDynamicStencilState = (PFN_vkCmdBindDynamicStencilState) gpa(dev, "vkCmdBindDynamicStencilState"); table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) gpa(dev, "vkCmdBindDescriptorSets"); table->CmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers) gpa(dev, "vkCmdBindVertexBuffers"); @@ -350,22 +350,22 @@ static inline void *loader_lookup_device_dispatch_table( return (void *) table->CreateDynamicViewportState; if (!strcmp(name, "DestroyDynamicViewportState")) return (void *) table->DestroyDynamicViewportState; - 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")) - return (void *) table->DestroyDynamicColorBlendState; - if (!strcmp(name, "CreateDynamicDepthState")) - return (void *) table->CreateDynamicDepthState; - if (!strcmp(name, "DestroyDynamicDepthState")) - return (void *) table->DestroyDynamicDepthState; + if (!strcmp(name, "CreateDynamicLineWidthState")) + return (void *) table->CreateDynamicLineWidthState; + if (!strcmp(name, "DestroyDynamicLineWidthState")) + return (void *) table->DestroyDynamicLineWidthState; + if (!strcmp(name, "CreateDynamicDepthBiasState")) + return (void *) table->CreateDynamicDepthBiasState; + if (!strcmp(name, "DestroyDynamicDepthBiasState")) + return (void *) table->DestroyDynamicDepthBiasState; + if (!strcmp(name, "CreateDynamicBlendState")) + return (void *) table->CreateDynamicBlendState; + if (!strcmp(name, "DestroyDynamicBlendState")) + return (void *) table->DestroyDynamicBlendState; + if (!strcmp(name, "CreateDynamicDepthBoundsState")) + return (void *) table->CreateDynamicDepthBoundsState; + if (!strcmp(name, "DestroyDynamicDepthBoundsState")) + return (void *) table->DestroyDynamicDepthBoundsState; if (!strcmp(name, "CreateDynamicStencilState")) return (void *) table->CreateDynamicStencilState; if (!strcmp(name, "DestroyDynamicStencilState")) @@ -400,14 +400,14 @@ static inline void *loader_lookup_device_dispatch_table( return (void *) table->CmdBindPipeline; if (!strcmp(name, "CmdBindDynamicViewportState")) return (void *) table->CmdBindDynamicViewportState; - 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, "CmdBindDynamicDepthState")) - return (void *) table->CmdBindDynamicDepthState; + if (!strcmp(name, "CmdBindDynamicLineWidthState")) + return (void *) table->CmdBindDynamicLineWidthState; + if (!strcmp(name, "CmdBindDynamicDepthBiasState")) + return (void *) table->CmdBindDynamicDepthBiasState; + if (!strcmp(name, "CmdBindDynamicBlendState")) + return (void *) table->CmdBindDynamicBlendState; + if (!strcmp(name, "CmdBindDynamicDepthBoundsState")) + return (void *) table->CmdBindDynamicDepthBoundsState; if (!strcmp(name, "CmdBindDynamicStencilState")) return (void *) table->CmdBindDynamicStencilState; if (!strcmp(name, "CmdBindDescriptorSets")) diff --git a/loader/trampoline.c b/loader/trampoline.c index e5fef11..2b15afe 100644 --- a/loader/trampoline.c +++ b/loader/trampoline.c @@ -1016,76 +1016,76 @@ LOADER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDy return disp->DestroyDynamicViewportState(device, dynamicViewportState); } -LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterLineState(VkDevice device, const VkDynamicRasterLineStateCreateInfo* pCreateInfo, VkDynamicRasterLineState* pState) +LOADER_EXPORT VkResult VKAPI vkCreateDynamicLineWidthState(VkDevice device, const VkDynamicLineWidthStateCreateInfo* pCreateInfo, VkDynamicLineWidthState* pState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->CreateDynamicRasterLineState(device, pCreateInfo, pState); + return disp->CreateDynamicLineWidthState(device, pCreateInfo, pState); } -LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterLineState(VkDevice device, VkDynamicRasterLineState dynamicRasterLineState) +LOADER_EXPORT VkResult VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->DestroyDynamicRasterLineState(device, dynamicRasterLineState); + return disp->DestroyDynamicLineWidthState(device, dynamicLineWidthState); } -LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterDepthBiasState(VkDevice device, const VkDynamicRasterDepthBiasStateCreateInfo* pCreateInfo, VkDynamicRasterDepthBiasState* pState) +LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthBiasState(VkDevice device, const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, VkDynamicDepthBiasState* pState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->CreateDynamicRasterDepthBiasState(device, pCreateInfo, pState); + return disp->CreateDynamicDepthBiasState(device, pCreateInfo, pState); } -LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterDepthBiasState(VkDevice device, VkDynamicRasterDepthBiasState dynamicRasterDepthBiasState) +LOADER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->DestroyDynamicRasterDepthBiasState(device, dynamicRasterDepthBiasState); + return disp->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState); } -LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) +LOADER_EXPORT VkResult VKAPI vkCreateDynamicBlendState(VkDevice device, const VkDynamicBlendStateCreateInfo* pCreateInfo, VkDynamicBlendState* pState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->CreateDynamicColorBlendState(device, pCreateInfo, pState); + return disp->CreateDynamicBlendState(device, pCreateInfo, pState); } -LOADER_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) +LOADER_EXPORT VkResult VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->DestroyDynamicColorBlendState(device, dynamicColorBlendState); + return disp->DestroyDynamicBlendState(device, dynamicBlendState); } -LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthState(VkDevice device, const VkDynamicDepthStateCreateInfo* pCreateInfo, VkDynamicDepthState* pState) +LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthBoundsState(VkDevice device, const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, VkDynamicDepthBoundsState* pState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->CreateDynamicDepthState(device, pCreateInfo, pState); + return disp->CreateDynamicDepthBoundsState(device, pCreateInfo, pState); } -LOADER_EXPORT VkResult VKAPI vkDestroyDynamicDepthState(VkDevice device, VkDynamicDepthState dynamicDepthState) +LOADER_EXPORT VkResult VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->DestroyDynamicDepthState(device, dynamicDepthState); + return disp->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState); } LOADER_EXPORT VkResult VKAPI vkCreateDynamicStencilState(VkDevice device, const VkDynamicStencilStateCreateInfo* pCreateInfoFront, const VkDynamicStencilStateCreateInfo* pCreateInfoBack, VkDynamicStencilState* pState) @@ -1247,40 +1247,40 @@ LOADER_EXPORT void VKAPI vkCmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, Vk disp->CmdBindDynamicViewportState(cmdBuffer, state); } -LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterLineState(VkCmdBuffer cmdBuffer, VkDynamicRasterLineState state) +LOADER_EXPORT void VKAPI vkCmdBindDynamicLineWidthState(VkCmdBuffer cmdBuffer, VkDynamicLineWidthState state) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(cmdBuffer); - disp->CmdBindDynamicRasterLineState(cmdBuffer, state); + disp->CmdBindDynamicLineWidthState(cmdBuffer, state); } -LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicRasterDepthBiasState state) +LOADER_EXPORT void VKAPI vkCmdBindDynamicDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicDepthBiasState state) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(cmdBuffer); - disp->CmdBindDynamicRasterDepthBiasState(cmdBuffer, state); + disp->CmdBindDynamicDepthBiasState(cmdBuffer, state); } -LOADER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState state) +LOADER_EXPORT void VKAPI vkCmdBindDynamicBlendState(VkCmdBuffer cmdBuffer, VkDynamicBlendState state) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(cmdBuffer); - disp->CmdBindDynamicColorBlendState(cmdBuffer, state); + disp->CmdBindDynamicBlendState(cmdBuffer, state); } -LOADER_EXPORT void VKAPI vkCmdBindDynamicDepthState(VkCmdBuffer cmdBuffer, VkDynamicDepthState state) +LOADER_EXPORT void VKAPI vkCmdBindDynamicDepthBoundsState(VkCmdBuffer cmdBuffer, VkDynamicDepthBoundsState state) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(cmdBuffer); - disp->CmdBindDynamicDepthState(cmdBuffer, state); + disp->CmdBindDynamicDepthBoundsState(cmdBuffer, state); } LOADER_EXPORT void VKAPI vkCmdBindDynamicStencilState(VkCmdBuffer cmdBuffer, VkDynamicStencilState state) diff --git a/vk-layer-generate.py b/vk-layer-generate.py index a3da742..dd6c754 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', 'VkDynamicRasterLineState', 'VkDynamicRasterDepthBiasState', 'VkDynamicColorBlendState', 'VkDynamicDepthState', 'VkDynamicStencilState', + for o in ['VkPipeline', 'VkDynamicViewportState', 'VkDynamicLineWidthState', 'VkDynamicDepthBiasState', 'VkDynamicBlendState', 'VkDynamicDepthBoundsState', 'VkDynamicStencilState', 'VkPipelineLayout', 'VkBuffer', 'VkEvent', 'VkQueryPool', 'VkRenderPass', 'VkFramebuffer']: cbv_txt.append('static void validate_object(VkCmdBuffer dispatchable_object, %s object)' % (o)) cbv_txt.append('{') @@ -1597,10 +1597,10 @@ class ThreadingSubcommand(Subcommand): 'VkDescriptorPool' : 'VK_OBJECT_TYPE_DESCRIPTOR_POOL', 'VkDescriptorSet' : 'VK_OBJECT_TYPE_DESCRIPTOR_SET', 'VkDynamicViewportState' : 'VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_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', - 'VkDynamicDepthState' : 'VK_OBJECT_TYPE_DYNAMIC_DEPTH_STATE', + 'VkDynamicLineWidthState' : 'VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE', + 'VkDynamicDepthBiasState' : 'VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE', + 'VkDynamicBlendState' : 'VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE', + 'VkDynamicDepthBoundsState' : 'VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE', 'VkDynamicStencilState' : 'VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE', 'VkFramebuffer' : 'VK_OBJECT_TYPE_FRAMEBUFFER', 'VkCmdPool' : 'VK_OBJECT_TYPE_CMD_POOL', diff --git a/vulkan.py b/vulkan.py index 086d277..959d8e9 100755 --- a/vulkan.py +++ b/vulkan.py @@ -209,10 +209,10 @@ core = Extension( "VkDescriptorPool", "VkDescriptorSet", "VkDynamicViewportState", - "VkDynamicRasterLineState", - "VkDynamicRasterDepthBiasState", - "VkDynamicColorBlendState", - "VkDynamicDepthState", + "VkDynamicLineWidthState", + "VkDynamicDepthBiasState", + "VkDynamicBlendState", + "VkDynamicDepthBoundsState", "VkDynamicStencilState", "VkRenderPass", "VkFramebuffer", @@ -674,41 +674,41 @@ core = Extension( [Param("VkDevice", "device"), Param("VkDynamicViewportState", "dynamicViewportState")]), - Proto("VkResult", "CreateDynamicRasterLineState", + Proto("VkResult", "CreateDynamicLineWidthState", [Param("VkDevice", "device"), - Param("const VkDynamicRasterLineStateCreateInfo*", "pCreateInfo"), - Param("VkDynamicRasterLineState*", "pState")]), + Param("const VkDynamicLineWidthStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicLineWidthState*", "pState")]), - Proto("VkResult", "DestroyDynamicRasterLineState", + Proto("VkResult", "DestroyDynamicLineWidthState", [Param("VkDevice", "device"), - Param("VkDynamicRasterLineState", "dynamicRasterLineState")]), + Param("VkDynamicLineWidthState", "dynamicLineWidthState")]), - Proto("VkResult", "CreateDynamicRasterDepthBiasState", + Proto("VkResult", "CreateDynamicDepthBiasState", [Param("VkDevice", "device"), - Param("const VkDynamicRasterDepthBiasStateCreateInfo*", "pCreateInfo"), - Param("VkDynamicRasterDepthBiasState*", "pState")]), + Param("const VkDynamicDepthBiasStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicDepthBiasState*", "pState")]), - Proto("VkResult", "DestroyDynamicRasterDepthBiasState", + Proto("VkResult", "DestroyDynamicDepthBiasState", [Param("VkDevice", "device"), - Param("VkDynamicRasterDepthBiasState", "dynamicRasterDepthBiasState")]), + Param("VkDynamicDepthBiasState", "dynamicDepthBiasState")]), - Proto("VkResult", "CreateDynamicColorBlendState", + Proto("VkResult", "CreateDynamicBlendState", [Param("VkDevice", "device"), - Param("const VkDynamicColorBlendStateCreateInfo*", "pCreateInfo"), - Param("VkDynamicColorBlendState*", "pState")]), + Param("const VkDynamicBlendStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicBlendState*", "pState")]), - Proto("VkResult", "DestroyDynamicColorBlendState", + Proto("VkResult", "DestroyDynamicBlendState", [Param("VkDevice", "device"), - Param("VkDynamicColorBlendState", "dynamicColorBlendState")]), + Param("VkDynamicBlendState", "DynamicBlendState")]), - Proto("VkResult", "CreateDynamicDepthState", + Proto("VkResult", "CreateDynamicDepthBoundsState", [Param("VkDevice", "device"), - Param("const VkDynamicDepthStateCreateInfo*", "pCreateInfo"), - Param("VkDynamicDepthState*", "pState")]), + Param("const VkDynamicDepthBoundsStateCreateInfo*", "pCreateInfo"), + Param("VkDynamicDepthBoundsState*", "pState")]), - Proto("VkResult", "DestroyDynamicDepthState", + Proto("VkResult", "DestroyDynamicDepthBoundsState", [Param("VkDevice", "device"), - Param("VkDynamicDepthState", "dynamicDepthState")]), + Param("VkDynamicDepthBoundsState", "dynamicDepthBoundsState")]), Proto("VkResult", "CreateDynamicStencilState", [Param("VkDevice", "device"), @@ -763,21 +763,21 @@ core = Extension( [Param("VkCmdBuffer", "cmdBuffer"), Param("VkDynamicViewportState", "dynamicViewportState")]), - Proto("void", "CmdBindDynamicRasterLineState", + Proto("void", "CmdBindDynamicLineWidthState", [Param("VkCmdBuffer", "cmdBuffer"), - Param("VkDynamicRasterLineState", "dynamicRasterLineState")]), + Param("VkDynamicLineWidthState", "dynamicLineWidthState")]), - Proto("void", "CmdBindDynamicRasterDepthBiasState", + Proto("void", "CmdBindDynamicDepthBiasState", [Param("VkCmdBuffer", "cmdBuffer"), - Param("VkDynamicRasterDepthBiasState", "dynamicRasterDepthBiasState")]), + Param("VkDynamicDepthBiasState", "dynamicDepthBiasState")]), - Proto("void", "CmdBindDynamicColorBlendState", + Proto("void", "CmdBindDynamicBlendState", [Param("VkCmdBuffer", "cmdBuffer"), - Param("VkDynamicColorBlendState", "dynamicColorBlendState")]), + Param("VkDynamicBlendState", "DynamicBlendState")]), - Proto("void", "CmdBindDynamicDepthState", + Proto("void", "CmdBindDynamicDepthBoundsState", [Param("VkCmdBuffer", "cmdBuffer"), - Param("VkDynamicDepthState", "dynamicDepthState")]), + Param("VkDynamicDepthBoundsState", "dynamicDepthBoundsState")]), Proto("void", "CmdBindDynamicStencilState", [Param("VkCmdBuffer", "cmdBuffer"), @@ -1169,10 +1169,10 @@ object_non_dispatch_list = [ "VkDescriptorPool", "VkDescriptorSet", "VkDynamicViewportState", - "VkDynamicRasterLineState", - "VkDynamicRasterDepthBiasState", - "VkDynamicColorBlendState", - "VkDynamicDepthState", + "VkDynamicLineWidthState", + "VkDynamicDepthBiasState", + "VkDynamicBlendState", + "VkDynamicDepthBoundsState", "VkDynamicStencilState", "VkRenderPass", "VkFramebuffer", -- 2.7.4