Update for Vulkan-Docs 1.2.176v1.2.176sdk.1.2.176.1-TAGsdk-1.2.176.0sdk-1.2.176

6 files changed, 1429 insertions, 812 deletions

diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 2073f3d..64aa226 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -93,7 +93,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION == 175, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 176, "Wrong VK_HEADER_VERSION!" );
 
 // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@@ -2280,6 +2280,11 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
     }
 
+    void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
+    }
+
     void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer,
                               float           minDepthBounds,
                               float           maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
@@ -2385,6 +2390,17 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
     }
 
+    void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
+    }
+
+    void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer,
+                                        uint32_t        patchControlPoints ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
+    }
+
     VkResult
       vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer                      commandBuffer,
                                       const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
@@ -2405,12 +2421,24 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
     }
 
+    void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer,
+                                            VkBool32        primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
+    }
+
     void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer     commandBuffer,
                                        VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
     }
 
+    void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer,
+                                             VkBool32        rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
+    }
+
     void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer,
                                                  uint32_t        pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
     {
@@ -5600,47 +5628,47 @@ namespace VULKAN_HPP_NAMESPACE
   enum class AccessFlagBits2KHR : VkAccessFlags2KHR
   {
     // clang-format off
-      e2None = VK_ACCESS_2_NONE_KHR
-    , e2IndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR
-    , e2IndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR
-    , e2VertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR
-    , e2UniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR
-    , e2InputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR
-    , e2ShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR
-    , e2ShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR
-    , e2ColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR
-    , e2ColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR
-    , e2DepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR
-    , e2DepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR
-    , e2TransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR
-    , e2TransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR
-    , e2HostRead = VK_ACCESS_2_HOST_READ_BIT_KHR
-    , e2HostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR
-    , e2MemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR
-    , e2MemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR
-    , e2ShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR
-    , e2ShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR
-    , e2ShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR
+      eNone = VK_ACCESS_2_NONE_KHR
+    , eIndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR
+    , eIndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR
+    , eVertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR
+    , eUniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR
+    , eInputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR
+    , eShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR
+    , eShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR
+    , eColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR
+    , eColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR
+    , eDepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR
+    , eDepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR
+    , eTransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR
+    , eTransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR
+    , eHostRead = VK_ACCESS_2_HOST_READ_BIT_KHR
+    , eHostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR
+    , eMemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR
+    , eMemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR
+    , eShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR
+    , eShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR
+    , eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-    , e2VideoDecodeRead = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR
-    , e2VideoDecodeWrite = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR
-    , e2VideoEncodeRead = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR
-    , e2VideoEncodeWrite = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR
+    , eVideoDecodeRead = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR
+    , eVideoDecodeWrite = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR
+    , eVideoEncodeRead = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR
+    , eVideoEncodeWrite = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    , e2TransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT
-    , e2TransformFeedbackCounterReadExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
-    , e2TransformFeedbackCounterWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT
-    , e2ConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT
-    , e2CommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV
-    , e2CommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV
-    , e2FragmentShadingRateAttachmentRead = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR
-    , e2AccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR
-    , e2AccelerationStructureWrite = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR
-    , e2FragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT
-    , e2ColorAttachmentReadNoncoherentExt = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT
-    , e2AccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV
-    , e2AccelerationStructureWriteNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV
-    , e2ShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV
+    , eTransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT
+    , eTransformFeedbackCounterReadExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
+    , eTransformFeedbackCounterWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT
+    , eConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT
+    , eCommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV
+    , eCommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV
+    , eFragmentShadingRateAttachmentRead = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR
+    , eAccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR
+    , eAccelerationStructureWrite = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR
+    , eFragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT
+    , eColorAttachmentReadNoncoherentExt = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT
+    , eAccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV
+    , eAccelerationStructureWriteNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV
+    , eShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV
     // clang-format on
   };
 
@@ -5648,44 +5676,44 @@ namespace VULKAN_HPP_NAMESPACE
   {
     switch ( value )
     {
-      case AccessFlagBits2KHR::e2None: return "2None";
-      case AccessFlagBits2KHR::e2IndirectCommandRead: return "2IndirectCommandRead";
-      case AccessFlagBits2KHR::e2IndexRead: return "2IndexRead";
-      case AccessFlagBits2KHR::e2VertexAttributeRead: return "2VertexAttributeRead";
-      case AccessFlagBits2KHR::e2UniformRead: return "2UniformRead";
-      case AccessFlagBits2KHR::e2InputAttachmentRead: return "2InputAttachmentRead";
-      case AccessFlagBits2KHR::e2ShaderRead: return "2ShaderRead";
-      case AccessFlagBits2KHR::e2ShaderWrite: return "2ShaderWrite";
-      case AccessFlagBits2KHR::e2ColorAttachmentRead: return "2ColorAttachmentRead";
-      case AccessFlagBits2KHR::e2ColorAttachmentWrite: return "2ColorAttachmentWrite";
-      case AccessFlagBits2KHR::e2DepthStencilAttachmentRead: return "2DepthStencilAttachmentRead";
-      case AccessFlagBits2KHR::e2DepthStencilAttachmentWrite: return "2DepthStencilAttachmentWrite";
-      case AccessFlagBits2KHR::e2TransferRead: return "2TransferRead";
-      case AccessFlagBits2KHR::e2TransferWrite: return "2TransferWrite";
-      case AccessFlagBits2KHR::e2HostRead: return "2HostRead";
-      case AccessFlagBits2KHR::e2HostWrite: return "2HostWrite";
-      case AccessFlagBits2KHR::e2MemoryRead: return "2MemoryRead";
-      case AccessFlagBits2KHR::e2MemoryWrite: return "2MemoryWrite";
-      case AccessFlagBits2KHR::e2ShaderSampledRead: return "2ShaderSampledRead";
-      case AccessFlagBits2KHR::e2ShaderStorageRead: return "2ShaderStorageRead";
-      case AccessFlagBits2KHR::e2ShaderStorageWrite: return "2ShaderStorageWrite";
+      case AccessFlagBits2KHR::eNone: return "None";
+      case AccessFlagBits2KHR::eIndirectCommandRead: return "IndirectCommandRead";
+      case AccessFlagBits2KHR::eIndexRead: return "IndexRead";
+      case AccessFlagBits2KHR::eVertexAttributeRead: return "VertexAttributeRead";
+      case AccessFlagBits2KHR::eUniformRead: return "UniformRead";
+      case AccessFlagBits2KHR::eInputAttachmentRead: return "InputAttachmentRead";
+      case AccessFlagBits2KHR::eShaderRead: return "ShaderRead";
+      case AccessFlagBits2KHR::eShaderWrite: return "ShaderWrite";
+      case AccessFlagBits2KHR::eColorAttachmentRead: return "ColorAttachmentRead";
+      case AccessFlagBits2KHR::eColorAttachmentWrite: return "ColorAttachmentWrite";
+      case AccessFlagBits2KHR::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead";
+      case AccessFlagBits2KHR::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite";
+      case AccessFlagBits2KHR::eTransferRead: return "TransferRead";
+      case AccessFlagBits2KHR::eTransferWrite: return "TransferWrite";
+      case AccessFlagBits2KHR::eHostRead: return "HostRead";
+      case AccessFlagBits2KHR::eHostWrite: return "HostWrite";
+      case AccessFlagBits2KHR::eMemoryRead: return "MemoryRead";
+      case AccessFlagBits2KHR::eMemoryWrite: return "MemoryWrite";
+      case AccessFlagBits2KHR::eShaderSampledRead: return "ShaderSampledRead";
+      case AccessFlagBits2KHR::eShaderStorageRead: return "ShaderStorageRead";
+      case AccessFlagBits2KHR::eShaderStorageWrite: return "ShaderStorageWrite";
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-      case AccessFlagBits2KHR::e2VideoDecodeRead: return "2VideoDecodeRead";
-      case AccessFlagBits2KHR::e2VideoDecodeWrite: return "2VideoDecodeWrite";
-      case AccessFlagBits2KHR::e2VideoEncodeRead: return "2VideoEncodeRead";
-      case AccessFlagBits2KHR::e2VideoEncodeWrite: return "2VideoEncodeWrite";
+      case AccessFlagBits2KHR::eVideoDecodeRead: return "VideoDecodeRead";
+      case AccessFlagBits2KHR::eVideoDecodeWrite: return "VideoDecodeWrite";
+      case AccessFlagBits2KHR::eVideoEncodeRead: return "VideoEncodeRead";
+      case AccessFlagBits2KHR::eVideoEncodeWrite: return "VideoEncodeWrite";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      case AccessFlagBits2KHR::e2TransformFeedbackWriteExt: return "2TransformFeedbackWriteExt";
-      case AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt: return "2TransformFeedbackCounterReadExt";
-      case AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt: return "2TransformFeedbackCounterWriteExt";
-      case AccessFlagBits2KHR::e2ConditionalRenderingReadExt: return "2ConditionalRenderingReadExt";
-      case AccessFlagBits2KHR::e2CommandPreprocessReadNv: return "2CommandPreprocessReadNv";
-      case AccessFlagBits2KHR::e2CommandPreprocessWriteNv: return "2CommandPreprocessWriteNv";
-      case AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead: return "2FragmentShadingRateAttachmentRead";
-      case AccessFlagBits2KHR::e2AccelerationStructureRead: return "2AccelerationStructureRead";
-      case AccessFlagBits2KHR::e2AccelerationStructureWrite: return "2AccelerationStructureWrite";
-      case AccessFlagBits2KHR::e2FragmentDensityMapReadExt: return "2FragmentDensityMapReadExt";
-      case AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt: return "2ColorAttachmentReadNoncoherentExt";
+      case AccessFlagBits2KHR::eTransformFeedbackWriteExt: return "TransformFeedbackWriteExt";
+      case AccessFlagBits2KHR::eTransformFeedbackCounterReadExt: return "TransformFeedbackCounterReadExt";
+      case AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt: return "TransformFeedbackCounterWriteExt";
+      case AccessFlagBits2KHR::eConditionalRenderingReadExt: return "ConditionalRenderingReadExt";
+      case AccessFlagBits2KHR::eCommandPreprocessReadNv: return "CommandPreprocessReadNv";
+      case AccessFlagBits2KHR::eCommandPreprocessWriteNv: return "CommandPreprocessWriteNv";
+      case AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead: return "FragmentShadingRateAttachmentRead";
+      case AccessFlagBits2KHR::eAccelerationStructureRead: return "AccelerationStructureRead";
+      case AccessFlagBits2KHR::eAccelerationStructureWrite: return "AccelerationStructureWrite";
+      case AccessFlagBits2KHR::eFragmentDensityMapReadExt: return "FragmentDensityMapReadExt";
+      case AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt: return "ColorAttachmentReadNoncoherentExt";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -7012,6 +7040,11 @@ namespace VULKAN_HPP_NAMESPACE
     eStencilTestEnableEXT           = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
     eStencilOpEXT                   = VK_DYNAMIC_STATE_STENCIL_OP_EXT,
     eVertexInputEXT                 = VK_DYNAMIC_STATE_VERTEX_INPUT_EXT,
+    ePatchControlPointsEXT          = VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT,
+    eRasterizerDiscardEnableEXT     = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT,
+    eDepthBiasEnableEXT             = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT,
+    eLogicOpEXT                     = VK_DYNAMIC_STATE_LOGIC_OP_EXT,
+    ePrimitiveRestartEnableEXT      = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
     eColorWriteEnableEXT            = VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT
   };
 
@@ -7050,6 +7083,11 @@ namespace VULKAN_HPP_NAMESPACE
       case DynamicState::eStencilTestEnableEXT: return "StencilTestEnableEXT";
       case DynamicState::eStencilOpEXT: return "StencilOpEXT";
       case DynamicState::eVertexInputEXT: return "VertexInputEXT";
+      case DynamicState::ePatchControlPointsEXT: return "PatchControlPointsEXT";
+      case DynamicState::eRasterizerDiscardEnableEXT: return "RasterizerDiscardEnableEXT";
+      case DynamicState::eDepthBiasEnableEXT: return "DepthBiasEnableEXT";
+      case DynamicState::eLogicOpEXT: return "LogicOpEXT";
+      case DynamicState::ePrimitiveRestartEnableEXT: return "PrimitiveRestartEnableEXT";
       case DynamicState::eColorWriteEnableEXT: return "ColorWriteEnableEXT";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
@@ -9226,48 +9264,48 @@ namespace VULKAN_HPP_NAMESPACE
   enum class PipelineStageFlagBits2KHR : VkPipelineStageFlags2KHR
   {
     // clang-format off
-      e2None = VK_PIPELINE_STAGE_2_NONE_KHR
-    , e2TopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR
-    , e2DrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR
-    , e2VertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR
-    , e2VertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR
-    , e2TessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR
-    , e2TessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR
-    , e2GeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR
-    , e2FragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR
-    , e2EarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR
-    , e2LateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR
-    , e2ColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR
-    , e2ComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR
-    , e2AllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR
-    , e2BottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR
-    , e2Host = VK_PIPELINE_STAGE_2_HOST_BIT_KHR
-    , e2AllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR
-    , e2AllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR
-    , e2Copy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR
-    , e2Resolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR
-    , e2Blit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR
-    , e2Clear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR
-    , e2IndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR
-    , e2VertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR
-    , e2PreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR
+      eNone = VK_PIPELINE_STAGE_2_NONE_KHR
+    , eTopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR
+    , eDrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR
+    , eVertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR
+    , eVertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR
+    , eTessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR
+    , eTessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR
+    , eGeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR
+    , eFragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR
+    , eEarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR
+    , eLateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR
+    , eColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR
+    , eComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR
+    , eAllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR
+    , eBottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR
+    , eHost = VK_PIPELINE_STAGE_2_HOST_BIT_KHR
+    , eAllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR
+    , eAllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR
+    , eCopy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR
+    , eResolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR
+    , eBlit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR
+    , eClear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR
+    , eIndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR
+    , eVertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR
+    , ePreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-    , e2VideoDecode = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR
-    , e2VideoEncode = VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR
+    , eVideoDecode = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR
+    , eVideoEncode = VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    , e2TransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT
-    , e2ConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT
-    , e2CommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV
-    , e2FragmentShadingRateAttachment = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR
-    , e2AccelerationStructureBuild = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR
-    , e2RayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR
-    , e2FragmentDensityProcessExt = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT
-    , e2TaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV
-    , e2MeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV
-    , e2AccelerationStructureBuildNv = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV
-    , e2RayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV
-    , e2ShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV
-    , e2Transfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR
+    , eTransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT
+    , eConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT
+    , eCommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV
+    , eFragmentShadingRateAttachment = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR
+    , eAccelerationStructureBuild = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR
+    , eRayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR
+    , eFragmentDensityProcessExt = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT
+    , eTaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV
+    , eMeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV
+    , eAccelerationStructureBuildNv = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV
+    , eRayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV
+    , eShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV
+    , eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR
     // clang-format on
   };
 
@@ -9275,44 +9313,44 @@ namespace VULKAN_HPP_NAMESPACE
   {
     switch ( value )
     {
-      case PipelineStageFlagBits2KHR::e2None: return "2None";
-      case PipelineStageFlagBits2KHR::e2TopOfPipe: return "2TopOfPipe";
-      case PipelineStageFlagBits2KHR::e2DrawIndirect: return "2DrawIndirect";
-      case PipelineStageFlagBits2KHR::e2VertexInput: return "2VertexInput";
-      case PipelineStageFlagBits2KHR::e2VertexShader: return "2VertexShader";
-      case PipelineStageFlagBits2KHR::e2TessellationControlShader: return "2TessellationControlShader";
-      case PipelineStageFlagBits2KHR::e2TessellationEvaluationShader: return "2TessellationEvaluationShader";
-      case PipelineStageFlagBits2KHR::e2GeometryShader: return "2GeometryShader";
-      case PipelineStageFlagBits2KHR::e2FragmentShader: return "2FragmentShader";
-      case PipelineStageFlagBits2KHR::e2EarlyFragmentTests: return "2EarlyFragmentTests";
-      case PipelineStageFlagBits2KHR::e2LateFragmentTests: return "2LateFragmentTests";
-      case PipelineStageFlagBits2KHR::e2ColorAttachmentOutput: return "2ColorAttachmentOutput";
-      case PipelineStageFlagBits2KHR::e2ComputeShader: return "2ComputeShader";
-      case PipelineStageFlagBits2KHR::e2AllTransfer: return "2AllTransfer";
-      case PipelineStageFlagBits2KHR::e2BottomOfPipe: return "2BottomOfPipe";
-      case PipelineStageFlagBits2KHR::e2Host: return "2Host";
-      case PipelineStageFlagBits2KHR::e2AllGraphics: return "2AllGraphics";
-      case PipelineStageFlagBits2KHR::e2AllCommands: return "2AllCommands";
-      case PipelineStageFlagBits2KHR::e2Copy: return "2Copy";
-      case PipelineStageFlagBits2KHR::e2Resolve: return "2Resolve";
-      case PipelineStageFlagBits2KHR::e2Blit: return "2Blit";
-      case PipelineStageFlagBits2KHR::e2Clear: return "2Clear";
-      case PipelineStageFlagBits2KHR::e2IndexInput: return "2IndexInput";
-      case PipelineStageFlagBits2KHR::e2VertexAttributeInput: return "2VertexAttributeInput";
-      case PipelineStageFlagBits2KHR::e2PreRasterizationShaders: return "2PreRasterizationShaders";
+      case PipelineStageFlagBits2KHR::eNone: return "None";
+      case PipelineStageFlagBits2KHR::eTopOfPipe: return "TopOfPipe";
+      case PipelineStageFlagBits2KHR::eDrawIndirect: return "DrawIndirect";
+      case PipelineStageFlagBits2KHR::eVertexInput: return "VertexInput";
+      case PipelineStageFlagBits2KHR::eVertexShader: return "VertexShader";
+      case PipelineStageFlagBits2KHR::eTessellationControlShader: return "TessellationControlShader";
+      case PipelineStageFlagBits2KHR::eTessellationEvaluationShader: return "TessellationEvaluationShader";
+      case PipelineStageFlagBits2KHR::eGeometryShader: return "GeometryShader";
+      case PipelineStageFlagBits2KHR::eFragmentShader: return "FragmentShader";
+      case PipelineStageFlagBits2KHR::eEarlyFragmentTests: return "EarlyFragmentTests";
+      case PipelineStageFlagBits2KHR::eLateFragmentTests: return "LateFragmentTests";
+      case PipelineStageFlagBits2KHR::eColorAttachmentOutput: return "ColorAttachmentOutput";
+      case PipelineStageFlagBits2KHR::eComputeShader: return "ComputeShader";
+      case PipelineStageFlagBits2KHR::eAllTransfer: return "AllTransfer";
+      case PipelineStageFlagBits2KHR::eBottomOfPipe: return "BottomOfPipe";
+      case PipelineStageFlagBits2KHR::eHost: return "Host";
+      case PipelineStageFlagBits2KHR::eAllGraphics: return "AllGraphics";
+      case PipelineStageFlagBits2KHR::eAllCommands: return "AllCommands";
+      case PipelineStageFlagBits2KHR::eCopy: return "Copy";
+      case PipelineStageFlagBits2KHR::eResolve: return "Resolve";
+      case PipelineStageFlagBits2KHR::eBlit: return "Blit";
+      case PipelineStageFlagBits2KHR::eClear: return "Clear";
+      case PipelineStageFlagBits2KHR::eIndexInput: return "IndexInput";
+      case PipelineStageFlagBits2KHR::eVertexAttributeInput: return "VertexAttributeInput";
+      case PipelineStageFlagBits2KHR::ePreRasterizationShaders: return "PreRasterizationShaders";
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-      case PipelineStageFlagBits2KHR::e2VideoDecode: return "2VideoDecode";
-      case PipelineStageFlagBits2KHR::e2VideoEncode: return "2VideoEncode";
+      case PipelineStageFlagBits2KHR::eVideoDecode: return "VideoDecode";
+      case PipelineStageFlagBits2KHR::eVideoEncode: return "VideoEncode";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      case PipelineStageFlagBits2KHR::e2TransformFeedbackExt: return "2TransformFeedbackExt";
-      case PipelineStageFlagBits2KHR::e2ConditionalRenderingExt: return "2ConditionalRenderingExt";
-      case PipelineStageFlagBits2KHR::e2CommandPreprocessNv: return "2CommandPreprocessNv";
-      case PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment: return "2FragmentShadingRateAttachment";
-      case PipelineStageFlagBits2KHR::e2AccelerationStructureBuild: return "2AccelerationStructureBuild";
-      case PipelineStageFlagBits2KHR::e2RayTracingShader: return "2RayTracingShader";
-      case PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt: return "2FragmentDensityProcessExt";
-      case PipelineStageFlagBits2KHR::e2TaskShaderNv: return "2TaskShaderNv";
-      case PipelineStageFlagBits2KHR::e2MeshShaderNv: return "2MeshShaderNv";
+      case PipelineStageFlagBits2KHR::eTransformFeedbackExt: return "TransformFeedbackExt";
+      case PipelineStageFlagBits2KHR::eConditionalRenderingExt: return "ConditionalRenderingExt";
+      case PipelineStageFlagBits2KHR::eCommandPreprocessNv: return "CommandPreprocessNv";
+      case PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment";
+      case PipelineStageFlagBits2KHR::eAccelerationStructureBuild: return "AccelerationStructureBuild";
+      case PipelineStageFlagBits2KHR::eRayTracingShader: return "RayTracingShader";
+      case PipelineStageFlagBits2KHR::eFragmentDensityProcessExt: return "FragmentDensityProcessExt";
+      case PipelineStageFlagBits2KHR::eTaskShaderNv: return "TaskShaderNv";
+      case PipelineStageFlagBits2KHR::eMeshShaderNv: return "MeshShaderNv";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -10859,6 +10897,7 @@ namespace VULKAN_HPP_NAMESPACE
     , eImportSemaphoreZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA
     , eSemaphoreGetZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+    , ePhysicalDeviceExtendedDynamicState2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
     , eScreenSurfaceCreateInfoQNX = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
@@ -11708,6 +11747,8 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA: return "ImportSemaphoreZirconHandleInfoFUCHSIA";
       case StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA: return "SemaphoreGetZirconHandleInfoFUCHSIA";
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
+      case StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT:
+        return "PhysicalDeviceExtendedDynamicState2FeaturesEXT";
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
       case StructureType::eScreenSurfaceCreateInfoQNX: return "ScreenSurfaceCreateInfoQNX";
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
@@ -12216,9 +12257,10 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   enum class VideoDecodeH264FieldLayoutFlagBitsEXT : VkVideoDecodeH264FieldLayoutFlagsEXT
   {
-    eVkVideoDecodeH264ProgressivePicturesOnly = VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT,
-    eLineInterlacedPlane                      = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT,
-    eSeparateInterlacedPlane                  = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT
+    eVkVideoDecodeH264ProgressivePicturesOnly        = VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT,
+    eVkVideoDecodeH264FieldLayoutLineInterlacedPlane = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT,
+    eVkVideoDecodeH264FieldLayoutSeparateInterlacedPlane =
+      VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264FieldLayoutFlagBitsEXT value )
@@ -12227,8 +12269,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       case VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly:
         return "VkVideoDecodeH264ProgressivePicturesOnly";
-      case VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane: return "LineInterlacedPlane";
-      case VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane: return "SeparateInterlacedPlane";
+      case VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutLineInterlacedPlane:
+        return "VkVideoDecodeH264FieldLayoutLineInterlacedPlane";
+      case VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutSeparateInterlacedPlane:
+        return "VkVideoDecodeH264FieldLayoutSeparateInterlacedPlane";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -12308,16 +12352,17 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   enum class VideoEncodeH264CreateFlagBitsEXT : VkVideoEncodeH264CreateFlagsEXT
   {
-    eDefault   = VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT,
-    eReserved0 = VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT
+    eVkVideoEncodeH264CreateDefault   = VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT,
+    eVkVideoEncodeH264CreateReserved0 = VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CreateFlagBitsEXT value )
   {
     switch ( value )
     {
-      case VideoEncodeH264CreateFlagBitsEXT::eDefault: return "Default";
-      case VideoEncodeH264CreateFlagBitsEXT::eReserved0: return "Reserved0";
+      case VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateDefault: return "VkVideoEncodeH264CreateDefault";
+      case VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateReserved0:
+        return "VkVideoEncodeH264CreateReserved0";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -12326,18 +12371,21 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   enum class VideoEncodeH264InputModeFlagBitsEXT : VkVideoEncodeH264InputModeFlagsEXT
   {
-    eFrame  = VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT,
-    eSlice  = VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT,
-    eNonVcl = VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT
+    eVkVideoEncodeH264InputModeFrame  = VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT,
+    eVkVideoEncodeH264InputModeSlice  = VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT,
+    eVkVideoEncodeH264InputModeNonVcl = VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264InputModeFlagBitsEXT value )
   {
     switch ( value )
     {
-      case VideoEncodeH264InputModeFlagBitsEXT::eFrame: return "Frame";
-      case VideoEncodeH264InputModeFlagBitsEXT::eSlice: return "Slice";
-      case VideoEncodeH264InputModeFlagBitsEXT::eNonVcl: return "NonVcl";
+      case VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeFrame:
+        return "VkVideoEncodeH264InputModeFrame";
+      case VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeSlice:
+        return "VkVideoEncodeH264InputModeSlice";
+      case VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeNonVcl:
+        return "VkVideoEncodeH264InputModeNonVcl";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -12346,18 +12394,21 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   enum class VideoEncodeH264OutputModeFlagBitsEXT : VkVideoEncodeH264OutputModeFlagsEXT
   {
-    eFrame  = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT,
-    eSlice  = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT,
-    eNonVcl = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT
+    eVkVideoEncodeH264OutputModeFrame  = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT,
+    eVkVideoEncodeH264OutputModeSlice  = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT,
+    eVkVideoEncodeH264OutputModeNonVcl = VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264OutputModeFlagBitsEXT value )
   {
     switch ( value )
     {
-      case VideoEncodeH264OutputModeFlagBitsEXT::eFrame: return "Frame";
-      case VideoEncodeH264OutputModeFlagBitsEXT::eSlice: return "Slice";
-      case VideoEncodeH264OutputModeFlagBitsEXT::eNonVcl: return "NonVcl";
+      case VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeFrame:
+        return "VkVideoEncodeH264OutputModeFrame";
+      case VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeSlice:
+        return "VkVideoEncodeH264OutputModeSlice";
+      case VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeNonVcl:
+        return "VkVideoEncodeH264OutputModeNonVcl";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -12657,34 +12708,32 @@ namespace VULKAN_HPP_NAMESPACE
     enum : VkFlags64
     {
       allFlags =
-        VkFlags64( AccessFlagBits2KHR::e2None ) | VkFlags64( AccessFlagBits2KHR::e2IndirectCommandRead ) |
-        VkFlags64( AccessFlagBits2KHR::e2IndexRead ) | VkFlags64( AccessFlagBits2KHR::e2VertexAttributeRead ) |
-        VkFlags64( AccessFlagBits2KHR::e2UniformRead ) | VkFlags64( AccessFlagBits2KHR::e2InputAttachmentRead ) |
-        VkFlags64( AccessFlagBits2KHR::e2ShaderRead ) | VkFlags64( AccessFlagBits2KHR::e2ShaderWrite ) |
-        VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentRead ) |
-        VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentWrite ) |
-        VkFlags64( AccessFlagBits2KHR::e2DepthStencilAttachmentRead ) |
-        VkFlags64( AccessFlagBits2KHR::e2DepthStencilAttachmentWrite ) |
-        VkFlags64( AccessFlagBits2KHR::e2TransferRead ) | VkFlags64( AccessFlagBits2KHR::e2TransferWrite ) |
-        VkFlags64( AccessFlagBits2KHR::e2HostRead ) | VkFlags64( AccessFlagBits2KHR::e2HostWrite ) |
-        VkFlags64( AccessFlagBits2KHR::e2MemoryRead ) | VkFlags64( AccessFlagBits2KHR::e2MemoryWrite ) |
-        VkFlags64( AccessFlagBits2KHR::e2ShaderSampledRead ) | VkFlags64( AccessFlagBits2KHR::e2ShaderStorageRead ) |
-        VkFlags64( AccessFlagBits2KHR::e2ShaderStorageWrite )
+        VkFlags64( AccessFlagBits2KHR::eNone ) | VkFlags64( AccessFlagBits2KHR::eIndirectCommandRead ) |
+        VkFlags64( AccessFlagBits2KHR::eIndexRead ) | VkFlags64( AccessFlagBits2KHR::eVertexAttributeRead ) |
+        VkFlags64( AccessFlagBits2KHR::eUniformRead ) | VkFlags64( AccessFlagBits2KHR::eInputAttachmentRead ) |
+        VkFlags64( AccessFlagBits2KHR::eShaderRead ) | VkFlags64( AccessFlagBits2KHR::eShaderWrite ) |
+        VkFlags64( AccessFlagBits2KHR::eColorAttachmentRead ) | VkFlags64( AccessFlagBits2KHR::eColorAttachmentWrite ) |
+        VkFlags64( AccessFlagBits2KHR::eDepthStencilAttachmentRead ) |
+        VkFlags64( AccessFlagBits2KHR::eDepthStencilAttachmentWrite ) | VkFlags64( AccessFlagBits2KHR::eTransferRead ) |
+        VkFlags64( AccessFlagBits2KHR::eTransferWrite ) | VkFlags64( AccessFlagBits2KHR::eHostRead ) |
+        VkFlags64( AccessFlagBits2KHR::eHostWrite ) | VkFlags64( AccessFlagBits2KHR::eMemoryRead ) |
+        VkFlags64( AccessFlagBits2KHR::eMemoryWrite ) | VkFlags64( AccessFlagBits2KHR::eShaderSampledRead ) |
+        VkFlags64( AccessFlagBits2KHR::eShaderStorageRead ) | VkFlags64( AccessFlagBits2KHR::eShaderStorageWrite )
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-        | VkFlags64( AccessFlagBits2KHR::e2VideoDecodeRead ) | VkFlags64( AccessFlagBits2KHR::e2VideoDecodeWrite ) |
-        VkFlags64( AccessFlagBits2KHR::e2VideoEncodeRead ) | VkFlags64( AccessFlagBits2KHR::e2VideoEncodeWrite )
+        | VkFlags64( AccessFlagBits2KHR::eVideoDecodeRead ) | VkFlags64( AccessFlagBits2KHR::eVideoDecodeWrite ) |
+        VkFlags64( AccessFlagBits2KHR::eVideoEncodeRead ) | VkFlags64( AccessFlagBits2KHR::eVideoEncodeWrite )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-        | VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackWriteExt ) |
-        VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt ) |
-        VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt ) |
-        VkFlags64( AccessFlagBits2KHR::e2ConditionalRenderingReadExt ) |
-        VkFlags64( AccessFlagBits2KHR::e2CommandPreprocessReadNv ) |
-        VkFlags64( AccessFlagBits2KHR::e2CommandPreprocessWriteNv ) |
-        VkFlags64( AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead ) |
-        VkFlags64( AccessFlagBits2KHR::e2AccelerationStructureRead ) |
-        VkFlags64( AccessFlagBits2KHR::e2AccelerationStructureWrite ) |
-        VkFlags64( AccessFlagBits2KHR::e2FragmentDensityMapReadExt ) |
-        VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt )
+        | VkFlags64( AccessFlagBits2KHR::eTransformFeedbackWriteExt ) |
+        VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterReadExt ) |
+        VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt ) |
+        VkFlags64( AccessFlagBits2KHR::eConditionalRenderingReadExt ) |
+        VkFlags64( AccessFlagBits2KHR::eCommandPreprocessReadNv ) |
+        VkFlags64( AccessFlagBits2KHR::eCommandPreprocessWriteNv ) |
+        VkFlags64( AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead ) |
+        VkFlags64( AccessFlagBits2KHR::eAccelerationStructureRead ) |
+        VkFlags64( AccessFlagBits2KHR::eAccelerationStructureWrite ) |
+        VkFlags64( AccessFlagBits2KHR::eFragmentDensityMapReadExt ) |
+        VkFlags64( AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt )
     };
   };
 
@@ -12717,84 +12766,84 @@ namespace VULKAN_HPP_NAMESPACE
       return "{}";
     std::string result;
 
-    if ( value & AccessFlagBits2KHR::e2IndirectCommandRead )
-      result += "2IndirectCommandRead | ";
-    if ( value & AccessFlagBits2KHR::e2IndexRead )
-      result += "2IndexRead | ";
-    if ( value & AccessFlagBits2KHR::e2VertexAttributeRead )
-      result += "2VertexAttributeRead | ";
-    if ( value & AccessFlagBits2KHR::e2UniformRead )
-      result += "2UniformRead | ";
-    if ( value & AccessFlagBits2KHR::e2InputAttachmentRead )
-      result += "2InputAttachmentRead | ";
-    if ( value & AccessFlagBits2KHR::e2ShaderRead )
-      result += "2ShaderRead | ";
-    if ( value & AccessFlagBits2KHR::e2ShaderWrite )
-      result += "2ShaderWrite | ";
-    if ( value & AccessFlagBits2KHR::e2ColorAttachmentRead )
-      result += "2ColorAttachmentRead | ";
-    if ( value & AccessFlagBits2KHR::e2ColorAttachmentWrite )
-      result += "2ColorAttachmentWrite | ";
-    if ( value & AccessFlagBits2KHR::e2DepthStencilAttachmentRead )
-      result += "2DepthStencilAttachmentRead | ";
-    if ( value & AccessFlagBits2KHR::e2DepthStencilAttachmentWrite )
-      result += "2DepthStencilAttachmentWrite | ";
-    if ( value & AccessFlagBits2KHR::e2TransferRead )
-      result += "2TransferRead | ";
-    if ( value & AccessFlagBits2KHR::e2TransferWrite )
-      result += "2TransferWrite | ";
-    if ( value & AccessFlagBits2KHR::e2HostRead )
-      result += "2HostRead | ";
-    if ( value & AccessFlagBits2KHR::e2HostWrite )
-      result += "2HostWrite | ";
-    if ( value & AccessFlagBits2KHR::e2MemoryRead )
-      result += "2MemoryRead | ";
-    if ( value & AccessFlagBits2KHR::e2MemoryWrite )
-      result += "2MemoryWrite | ";
-    if ( value & AccessFlagBits2KHR::e2ShaderSampledRead )
-      result += "2ShaderSampledRead | ";
-    if ( value & AccessFlagBits2KHR::e2ShaderStorageRead )
-      result += "2ShaderStorageRead | ";
-    if ( value & AccessFlagBits2KHR::e2ShaderStorageWrite )
-      result += "2ShaderStorageWrite | ";
+    if ( value & AccessFlagBits2KHR::eIndirectCommandRead )
+      result += "IndirectCommandRead | ";
+    if ( value & AccessFlagBits2KHR::eIndexRead )
+      result += "IndexRead | ";
+    if ( value & AccessFlagBits2KHR::eVertexAttributeRead )
+      result += "VertexAttributeRead | ";
+    if ( value & AccessFlagBits2KHR::eUniformRead )
+      result += "UniformRead | ";
+    if ( value & AccessFlagBits2KHR::eInputAttachmentRead )
+      result += "InputAttachmentRead | ";
+    if ( value & AccessFlagBits2KHR::eShaderRead )
+      result += "ShaderRead | ";
+    if ( value & AccessFlagBits2KHR::eShaderWrite )
+      result += "ShaderWrite | ";
+    if ( value & AccessFlagBits2KHR::eColorAttachmentRead )
+      result += "ColorAttachmentRead | ";
+    if ( value & AccessFlagBits2KHR::eColorAttachmentWrite )
+      result += "ColorAttachmentWrite | ";
+    if ( value & AccessFlagBits2KHR::eDepthStencilAttachmentRead )
+      result += "DepthStencilAttachmentRead | ";
+    if ( value & AccessFlagBits2KHR::eDepthStencilAttachmentWrite )
+      result += "DepthStencilAttachmentWrite | ";
+    if ( value & AccessFlagBits2KHR::eTransferRead )
+      result += "TransferRead | ";
+    if ( value & AccessFlagBits2KHR::eTransferWrite )
+      result += "TransferWrite | ";
+    if ( value & AccessFlagBits2KHR::eHostRead )
+      result += "HostRead | ";
+    if ( value & AccessFlagBits2KHR::eHostWrite )
+      result += "HostWrite | ";
+    if ( value & AccessFlagBits2KHR::eMemoryRead )
+      result += "MemoryRead | ";
+    if ( value & AccessFlagBits2KHR::eMemoryWrite )
+      result += "MemoryWrite | ";
+    if ( value & AccessFlagBits2KHR::eShaderSampledRead )
+      result += "ShaderSampledRead | ";
+    if ( value & AccessFlagBits2KHR::eShaderStorageRead )
+      result += "ShaderStorageRead | ";
+    if ( value & AccessFlagBits2KHR::eShaderStorageWrite )
+      result += "ShaderStorageWrite | ";
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-    if ( value & AccessFlagBits2KHR::e2VideoDecodeRead )
-      result += "2VideoDecodeRead | ";
+    if ( value & AccessFlagBits2KHR::eVideoDecodeRead )
+      result += "VideoDecodeRead | ";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-    if ( value & AccessFlagBits2KHR::e2VideoDecodeWrite )
-      result += "2VideoDecodeWrite | ";
+    if ( value & AccessFlagBits2KHR::eVideoDecodeWrite )
+      result += "VideoDecodeWrite | ";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-    if ( value & AccessFlagBits2KHR::e2VideoEncodeRead )
-      result += "2VideoEncodeRead | ";
+    if ( value & AccessFlagBits2KHR::eVideoEncodeRead )
+      result += "VideoEncodeRead | ";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-    if ( value & AccessFlagBits2KHR::e2VideoEncodeWrite )
-      result += "2VideoEncodeWrite | ";
+    if ( value & AccessFlagBits2KHR::eVideoEncodeWrite )
+      result += "VideoEncodeWrite | ";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    if ( value & AccessFlagBits2KHR::e2TransformFeedbackWriteExt )
-      result += "2TransformFeedbackWriteExt | ";
-    if ( value & AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt )
-      result += "2TransformFeedbackCounterReadExt | ";
-    if ( value & AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt )
-      result += "2TransformFeedbackCounterWriteExt | ";
-    if ( value & AccessFlagBits2KHR::e2ConditionalRenderingReadExt )
-      result += "2ConditionalRenderingReadExt | ";
-    if ( value & AccessFlagBits2KHR::e2CommandPreprocessReadNv )
-      result += "2CommandPreprocessReadNv | ";
-    if ( value & AccessFlagBits2KHR::e2CommandPreprocessWriteNv )
-      result += "2CommandPreprocessWriteNv | ";
-    if ( value & AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead )
-      result += "2FragmentShadingRateAttachmentRead | ";
-    if ( value & AccessFlagBits2KHR::e2AccelerationStructureRead )
-      result += "2AccelerationStructureRead | ";
-    if ( value & AccessFlagBits2KHR::e2AccelerationStructureWrite )
-      result += "2AccelerationStructureWrite | ";
-    if ( value & AccessFlagBits2KHR::e2FragmentDensityMapReadExt )
-      result += "2FragmentDensityMapReadExt | ";
-    if ( value & AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt )
-      result += "2ColorAttachmentReadNoncoherentExt | ";
+    if ( value & AccessFlagBits2KHR::eTransformFeedbackWriteExt )
+      result += "TransformFeedbackWriteExt | ";
+    if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterReadExt )
+      result += "TransformFeedbackCounterReadExt | ";
+    if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt )
+      result += "TransformFeedbackCounterWriteExt | ";
+    if ( value & AccessFlagBits2KHR::eConditionalRenderingReadExt )
+      result += "ConditionalRenderingReadExt | ";
+    if ( value & AccessFlagBits2KHR::eCommandPreprocessReadNv )
+      result += "CommandPreprocessReadNv | ";
+    if ( value & AccessFlagBits2KHR::eCommandPreprocessWriteNv )
+      result += "CommandPreprocessWriteNv | ";
+    if ( value & AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead )
+      result += "FragmentShadingRateAttachmentRead | ";
+    if ( value & AccessFlagBits2KHR::eAccelerationStructureRead )
+      result += "AccelerationStructureRead | ";
+    if ( value & AccessFlagBits2KHR::eAccelerationStructureWrite )
+      result += "AccelerationStructureWrite | ";
+    if ( value & AccessFlagBits2KHR::eFragmentDensityMapReadExt )
+      result += "FragmentDensityMapReadExt | ";
+    if ( value & AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt )
+      result += "ColorAttachmentReadNoncoherentExt | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
@@ -16512,35 +16561,35 @@ namespace VULKAN_HPP_NAMESPACE
     enum : VkFlags64
     {
       allFlags =
-        VkFlags64( PipelineStageFlagBits2KHR::e2None ) | VkFlags64( PipelineStageFlagBits2KHR::e2TopOfPipe ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2DrawIndirect ) | VkFlags64( PipelineStageFlagBits2KHR::e2VertexInput ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2VertexShader ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2TessellationControlShader ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2TessellationEvaluationShader ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2GeometryShader ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2FragmentShader ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2EarlyFragmentTests ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2LateFragmentTests ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2ColorAttachmentOutput ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2ComputeShader ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2AllTransfer ) | VkFlags64( PipelineStageFlagBits2KHR::e2BottomOfPipe ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2Host ) | VkFlags64( PipelineStageFlagBits2KHR::e2AllGraphics ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2AllCommands ) | VkFlags64( PipelineStageFlagBits2KHR::e2Copy ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2Resolve ) | VkFlags64( PipelineStageFlagBits2KHR::e2Blit ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2Clear ) | VkFlags64( PipelineStageFlagBits2KHR::e2IndexInput ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2VertexAttributeInput ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2PreRasterizationShaders )
+        VkFlags64( PipelineStageFlagBits2KHR::eNone ) | VkFlags64( PipelineStageFlagBits2KHR::eTopOfPipe ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eDrawIndirect ) | VkFlags64( PipelineStageFlagBits2KHR::eVertexInput ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eVertexShader ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eTessellationControlShader ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eTessellationEvaluationShader ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eGeometryShader ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eFragmentShader ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eEarlyFragmentTests ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eLateFragmentTests ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eColorAttachmentOutput ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eComputeShader ) | VkFlags64( PipelineStageFlagBits2KHR::eAllTransfer ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eBottomOfPipe ) | VkFlags64( PipelineStageFlagBits2KHR::eHost ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eAllGraphics ) | VkFlags64( PipelineStageFlagBits2KHR::eAllCommands ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eCopy ) | VkFlags64( PipelineStageFlagBits2KHR::eResolve ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eBlit ) | VkFlags64( PipelineStageFlagBits2KHR::eClear ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eIndexInput ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eVertexAttributeInput ) |
+        VkFlags64( PipelineStageFlagBits2KHR::ePreRasterizationShaders )
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-        | VkFlags64( PipelineStageFlagBits2KHR::e2VideoDecode ) | VkFlags64( PipelineStageFlagBits2KHR::e2VideoEncode )
+        | VkFlags64( PipelineStageFlagBits2KHR::eVideoDecode ) | VkFlags64( PipelineStageFlagBits2KHR::eVideoEncode )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-        | VkFlags64( PipelineStageFlagBits2KHR::e2TransformFeedbackExt ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2ConditionalRenderingExt ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2CommandPreprocessNv ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2AccelerationStructureBuild ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2RayTracingShader ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt ) |
-        VkFlags64( PipelineStageFlagBits2KHR::e2TaskShaderNv ) | VkFlags64( PipelineStageFlagBits2KHR::e2MeshShaderNv )
+        | VkFlags64( PipelineStageFlagBits2KHR::eTransformFeedbackExt ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eConditionalRenderingExt ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eCommandPreprocessNv ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eAccelerationStructureBuild ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eRayTracingShader ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eFragmentDensityProcessExt ) |
+        VkFlags64( PipelineStageFlagBits2KHR::eTaskShaderNv ) | VkFlags64( PipelineStageFlagBits2KHR::eMeshShaderNv )
     };
   };
 
@@ -16574,80 +16623,80 @@ namespace VULKAN_HPP_NAMESPACE
       return "{}";
     std::string result;
 
-    if ( value & PipelineStageFlagBits2KHR::e2TopOfPipe )
-      result += "2TopOfPipe | ";
-    if ( value & PipelineStageFlagBits2KHR::e2DrawIndirect )
-      result += "2DrawIndirect | ";
-    if ( value & PipelineStageFlagBits2KHR::e2VertexInput )
-      result += "2VertexInput | ";
-    if ( value & PipelineStageFlagBits2KHR::e2VertexShader )
-      result += "2VertexShader | ";
-    if ( value & PipelineStageFlagBits2KHR::e2TessellationControlShader )
-      result += "2TessellationControlShader | ";
-    if ( value & PipelineStageFlagBits2KHR::e2TessellationEvaluationShader )
-      result += "2TessellationEvaluationShader | ";
-    if ( value & PipelineStageFlagBits2KHR::e2GeometryShader )
-      result += "2GeometryShader | ";
-    if ( value & PipelineStageFlagBits2KHR::e2FragmentShader )
-      result += "2FragmentShader | ";
-    if ( value & PipelineStageFlagBits2KHR::e2EarlyFragmentTests )
-      result += "2EarlyFragmentTests | ";
-    if ( value & PipelineStageFlagBits2KHR::e2LateFragmentTests )
-      result += "2LateFragmentTests | ";
-    if ( value & PipelineStageFlagBits2KHR::e2ColorAttachmentOutput )
-      result += "2ColorAttachmentOutput | ";
-    if ( value & PipelineStageFlagBits2KHR::e2ComputeShader )
-      result += "2ComputeShader | ";
-    if ( value & PipelineStageFlagBits2KHR::e2AllTransfer )
-      result += "2AllTransfer | ";
-    if ( value & PipelineStageFlagBits2KHR::e2BottomOfPipe )
-      result += "2BottomOfPipe | ";
-    if ( value & PipelineStageFlagBits2KHR::e2Host )
-      result += "2Host | ";
-    if ( value & PipelineStageFlagBits2KHR::e2AllGraphics )
-      result += "2AllGraphics | ";
-    if ( value & PipelineStageFlagBits2KHR::e2AllCommands )
-      result += "2AllCommands | ";
-    if ( value & PipelineStageFlagBits2KHR::e2Copy )
-      result += "2Copy | ";
-    if ( value & PipelineStageFlagBits2KHR::e2Resolve )
-      result += "2Resolve | ";
-    if ( value & PipelineStageFlagBits2KHR::e2Blit )
-      result += "2Blit | ";
-    if ( value & PipelineStageFlagBits2KHR::e2Clear )
-      result += "2Clear | ";
-    if ( value & PipelineStageFlagBits2KHR::e2IndexInput )
-      result += "2IndexInput | ";
-    if ( value & PipelineStageFlagBits2KHR::e2VertexAttributeInput )
-      result += "2VertexAttributeInput | ";
-    if ( value & PipelineStageFlagBits2KHR::e2PreRasterizationShaders )
-      result += "2PreRasterizationShaders | ";
+    if ( value & PipelineStageFlagBits2KHR::eTopOfPipe )
+      result += "TopOfPipe | ";
+    if ( value & PipelineStageFlagBits2KHR::eDrawIndirect )
+      result += "DrawIndirect | ";
+    if ( value & PipelineStageFlagBits2KHR::eVertexInput )
+      result += "VertexInput | ";
+    if ( value & PipelineStageFlagBits2KHR::eVertexShader )
+      result += "VertexShader | ";
+    if ( value & PipelineStageFlagBits2KHR::eTessellationControlShader )
+      result += "TessellationControlShader | ";
+    if ( value & PipelineStageFlagBits2KHR::eTessellationEvaluationShader )
+      result += "TessellationEvaluationShader | ";
+    if ( value & PipelineStageFlagBits2KHR::eGeometryShader )
+      result += "GeometryShader | ";
+    if ( value & PipelineStageFlagBits2KHR::eFragmentShader )
+      result += "FragmentShader | ";
+    if ( value & PipelineStageFlagBits2KHR::eEarlyFragmentTests )
+      result += "EarlyFragmentTests | ";
+    if ( value & PipelineStageFlagBits2KHR::eLateFragmentTests )
+      result += "LateFragmentTests | ";
+    if ( value & PipelineStageFlagBits2KHR::eColorAttachmentOutput )
+      result += "ColorAttachmentOutput | ";
+    if ( value & PipelineStageFlagBits2KHR::eComputeShader )
+      result += "ComputeShader | ";
+    if ( value & PipelineStageFlagBits2KHR::eAllTransfer )
+      result += "AllTransfer | ";
+    if ( value & PipelineStageFlagBits2KHR::eBottomOfPipe )
+      result += "BottomOfPipe | ";
+    if ( value & PipelineStageFlagBits2KHR::eHost )
+      result += "Host | ";
+    if ( value & PipelineStageFlagBits2KHR::eAllGraphics )
+      result += "AllGraphics | ";
+    if ( value & PipelineStageFlagBits2KHR::eAllCommands )
+      result += "AllCommands | ";
+    if ( value & PipelineStageFlagBits2KHR::eCopy )
+      result += "Copy | ";
+    if ( value & PipelineStageFlagBits2KHR::eResolve )
+      result += "Resolve | ";
+    if ( value & PipelineStageFlagBits2KHR::eBlit )
+      result += "Blit | ";
+    if ( value & PipelineStageFlagBits2KHR::eClear )
+      result += "Clear | ";
+    if ( value & PipelineStageFlagBits2KHR::eIndexInput )
+      result += "IndexInput | ";
+    if ( value & PipelineStageFlagBits2KHR::eVertexAttributeInput )
+      result += "VertexAttributeInput | ";
+    if ( value & PipelineStageFlagBits2KHR::ePreRasterizationShaders )
+      result += "PreRasterizationShaders | ";
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-    if ( value & PipelineStageFlagBits2KHR::e2VideoDecode )
-      result += "2VideoDecode | ";
+    if ( value & PipelineStageFlagBits2KHR::eVideoDecode )
+      result += "VideoDecode | ";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-    if ( value & PipelineStageFlagBits2KHR::e2VideoEncode )
-      result += "2VideoEncode | ";
+    if ( value & PipelineStageFlagBits2KHR::eVideoEncode )
+      result += "VideoEncode | ";
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    if ( value & PipelineStageFlagBits2KHR::e2TransformFeedbackExt )
-      result += "2TransformFeedbackExt | ";
-    if ( value & PipelineStageFlagBits2KHR::e2ConditionalRenderingExt )
-      result += "2ConditionalRenderingExt | ";
-    if ( value & PipelineStageFlagBits2KHR::e2CommandPreprocessNv )
-      result += "2CommandPreprocessNv | ";
-    if ( value & PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment )
-      result += "2FragmentShadingRateAttachment | ";
-    if ( value & PipelineStageFlagBits2KHR::e2AccelerationStructureBuild )
-      result += "2AccelerationStructureBuild | ";
-    if ( value & PipelineStageFlagBits2KHR::e2RayTracingShader )
-      result += "2RayTracingShader | ";
-    if ( value & PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt )
-      result += "2FragmentDensityProcessExt | ";
-    if ( value & PipelineStageFlagBits2KHR::e2TaskShaderNv )
-      result += "2TaskShaderNv | ";
-    if ( value & PipelineStageFlagBits2KHR::e2MeshShaderNv )
-      result += "2MeshShaderNv | ";
+    if ( value & PipelineStageFlagBits2KHR::eTransformFeedbackExt )
+      result += "TransformFeedbackExt | ";
+    if ( value & PipelineStageFlagBits2KHR::eConditionalRenderingExt )
+      result += "ConditionalRenderingExt | ";
+    if ( value & PipelineStageFlagBits2KHR::eCommandPreprocessNv )
+      result += "CommandPreprocessNv | ";
+    if ( value & PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment )
+      result += "FragmentShadingRateAttachment | ";
+    if ( value & PipelineStageFlagBits2KHR::eAccelerationStructureBuild )
+      result += "AccelerationStructureBuild | ";
+    if ( value & PipelineStageFlagBits2KHR::eRayTracingShader )
+      result += "RayTracingShader | ";
+    if ( value & PipelineStageFlagBits2KHR::eFragmentDensityProcessExt )
+      result += "FragmentDensityProcessExt | ";
+    if ( value & PipelineStageFlagBits2KHR::eTaskShaderNv )
+      result += "TaskShaderNv | ";
+    if ( value & PipelineStageFlagBits2KHR::eMeshShaderNv )
+      result += "MeshShaderNv | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
@@ -18425,8 +18474,8 @@ namespace VULKAN_HPP_NAMESPACE
     enum : VkFlags
     {
       allFlags = VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly ) |
-                 VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane ) |
-                 VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane )
+                 VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutLineInterlacedPlane ) |
+                 VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutSeparateInterlacedPlane )
     };
   };
 
@@ -18460,10 +18509,10 @@ namespace VULKAN_HPP_NAMESPACE
       return "{}";
     std::string result;
 
-    if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane )
-      result += "LineInterlacedPlane | ";
-    if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane )
-      result += "SeparateInterlacedPlane | ";
+    if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutLineInterlacedPlane )
+      result += "VkVideoDecodeH264FieldLayoutLineInterlacedPlane | ";
+    if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264FieldLayoutSeparateInterlacedPlane )
+      result += "VkVideoDecodeH264FieldLayoutSeparateInterlacedPlane | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -18624,8 +18673,8 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum : VkFlags
     {
-      allFlags =
-        VkFlags( VideoEncodeH264CreateFlagBitsEXT::eDefault ) | VkFlags( VideoEncodeH264CreateFlagBitsEXT::eReserved0 )
+      allFlags = VkFlags( VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateDefault ) |
+                 VkFlags( VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateReserved0 )
     };
   };
 
@@ -18659,8 +18708,8 @@ namespace VULKAN_HPP_NAMESPACE
       return "{}";
     std::string result;
 
-    if ( value & VideoEncodeH264CreateFlagBitsEXT::eReserved0 )
-      result += "Reserved0 | ";
+    if ( value & VideoEncodeH264CreateFlagBitsEXT::eVkVideoEncodeH264CreateReserved0 )
+      result += "VkVideoEncodeH264CreateReserved0 | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -18674,9 +18723,9 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum : VkFlags
     {
-      allFlags = VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eFrame ) |
-                 VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eSlice ) |
-                 VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eNonVcl )
+      allFlags = VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeFrame ) |
+                 VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeSlice ) |
+                 VkFlags( VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeNonVcl )
     };
   };
 
@@ -18710,12 +18759,12 @@ namespace VULKAN_HPP_NAMESPACE
       return "{}";
     std::string result;
 
-    if ( value & VideoEncodeH264InputModeFlagBitsEXT::eFrame )
-      result += "Frame | ";
-    if ( value & VideoEncodeH264InputModeFlagBitsEXT::eSlice )
-      result += "Slice | ";
-    if ( value & VideoEncodeH264InputModeFlagBitsEXT::eNonVcl )
-      result += "NonVcl | ";
+    if ( value & VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeFrame )
+      result += "VkVideoEncodeH264InputModeFrame | ";
+    if ( value & VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeSlice )
+      result += "VkVideoEncodeH264InputModeSlice | ";
+    if ( value & VideoEncodeH264InputModeFlagBitsEXT::eVkVideoEncodeH264InputModeNonVcl )
+      result += "VkVideoEncodeH264InputModeNonVcl | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -18729,9 +18778,9 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum : VkFlags
     {
-      allFlags = VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eFrame ) |
-                 VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eSlice ) |
-                 VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eNonVcl )
+      allFlags = VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeFrame ) |
+                 VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeSlice ) |
+                 VkFlags( VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeNonVcl )
     };
   };
 
@@ -18765,12 +18814,12 @@ namespace VULKAN_HPP_NAMESPACE
       return "{}";
     std::string result;
 
-    if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eFrame )
-      result += "Frame | ";
-    if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eSlice )
-      result += "Slice | ";
-    if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eNonVcl )
-      result += "NonVcl | ";
+    if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeFrame )
+      result += "VkVideoEncodeH264OutputModeFrame | ";
+    if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeSlice )
+      result += "VkVideoEncodeH264OutputModeSlice | ";
+    if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eVkVideoEncodeH264OutputModeNonVcl )
+      result += "VkVideoEncodeH264OutputModeNonVcl | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -19827,13 +19876,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
 
   public:
-    VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT : m_accelerationStructureKHR( VK_NULL_HANDLE )
-    {}
-
-    VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_accelerationStructureKHR( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default;
+    VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT
       AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
       : m_accelerationStructureKHR( accelerationStructureKHR )
@@ -19849,7 +19893,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_accelerationStructureKHR = VK_NULL_HANDLE;
+      m_accelerationStructureKHR = {};
       return *this;
     }
 
@@ -19888,7 +19932,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkAccelerationStructureKHR m_accelerationStructureKHR;
+    VkAccelerationStructureKHR m_accelerationStructureKHR = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ),
                  "handle and wrapper have different size!" );
@@ -20892,10 +20936,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
 
   public:
-    VULKAN_HPP_CONSTEXPR Buffer() VULKAN_HPP_NOEXCEPT : m_buffer( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_buffer( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Buffer() = default;
+    VULKAN_HPP_CONSTEXPR         Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -20908,7 +20950,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_buffer = VK_NULL_HANDLE;
+      m_buffer = {};
       return *this;
     }
 
@@ -20947,7 +20989,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkBuffer m_buffer;
+    VkBuffer m_buffer = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ),
                  "handle and wrapper have different size!" );
@@ -22062,12 +22104,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
 
   public:
-    VULKAN_HPP_CONSTEXPR AccelerationStructureNV() VULKAN_HPP_NOEXCEPT : m_accelerationStructureNV( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_accelerationStructureNV( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default;
+    VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT
       AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
       : m_accelerationStructureNV( accelerationStructureNV )
@@ -22083,7 +22121,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_accelerationStructureNV = VK_NULL_HANDLE;
+      m_accelerationStructureNV = {};
       return *this;
     }
 
@@ -22122,7 +22160,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkAccelerationStructureNV m_accelerationStructureNV;
+    VkAccelerationStructureNV m_accelerationStructureNV = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ),
                  "handle and wrapper have different size!" );
@@ -22344,10 +22382,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
 
   public:
-    VULKAN_HPP_CONSTEXPR SwapchainKHR() VULKAN_HPP_NOEXCEPT : m_swapchainKHR( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         SwapchainKHR() = default;
+    VULKAN_HPP_CONSTEXPR         SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
       : m_swapchainKHR( swapchainKHR )
     {}
@@ -22362,7 +22398,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_swapchainKHR = VK_NULL_HANDLE;
+      m_swapchainKHR = {};
       return *this;
     }
 
@@ -22401,7 +22437,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkSwapchainKHR m_swapchainKHR;
+    VkSwapchainKHR m_swapchainKHR = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ),
                  "handle and wrapper have different size!" );
@@ -22443,10 +22479,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
 
   public:
-    VULKAN_HPP_CONSTEXPR Semaphore() VULKAN_HPP_NOEXCEPT : m_semaphore( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_semaphore( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Semaphore() = default;
+    VULKAN_HPP_CONSTEXPR         Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -22459,7 +22493,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_semaphore = VK_NULL_HANDLE;
+      m_semaphore = {};
       return *this;
     }
 
@@ -22498,7 +22532,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkSemaphore m_semaphore;
+    VkSemaphore m_semaphore = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ),
                  "handle and wrapper have different size!" );
@@ -22540,10 +22574,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
 
   public:
-    VULKAN_HPP_CONSTEXPR Fence() VULKAN_HPP_NOEXCEPT : m_fence( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_fence( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Fence() = default;
+    VULKAN_HPP_CONSTEXPR         Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -22556,7 +22588,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_fence = VK_NULL_HANDLE;
+      m_fence = {};
       return *this;
     }
 
@@ -22595,7 +22627,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkFence m_fence;
+    VkFence m_fence = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ),
                  "handle and wrapper have different size!" );
@@ -24594,10 +24626,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
 
   public:
-    VULKAN_HPP_CONSTEXPR DeviceMemory() VULKAN_HPP_NOEXCEPT : m_deviceMemory( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         DeviceMemory() = default;
+    VULKAN_HPP_CONSTEXPR         DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
       : m_deviceMemory( deviceMemory )
     {}
@@ -24612,7 +24642,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_deviceMemory = VK_NULL_HANDLE;
+      m_deviceMemory = {};
       return *this;
     }
 
@@ -24651,7 +24681,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDeviceMemory m_deviceMemory;
+    VkDeviceMemory m_deviceMemory = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ),
                  "handle and wrapper have different size!" );
@@ -25320,10 +25350,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
 
   public:
-    VULKAN_HPP_CONSTEXPR Image() VULKAN_HPP_NOEXCEPT : m_image( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_image( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Image() = default;
+    VULKAN_HPP_CONSTEXPR         Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -25336,7 +25364,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_image = VK_NULL_HANDLE;
+      m_image = {};
       return *this;
     }
 
@@ -25375,7 +25403,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkImage m_image;
+    VkImage m_image = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ),
                  "handle and wrapper have different size!" );
@@ -29249,10 +29277,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
 
   public:
-    VULKAN_HPP_CONSTEXPR CommandPool() VULKAN_HPP_NOEXCEPT : m_commandPool( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_commandPool( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         CommandPool() = default;
+    VULKAN_HPP_CONSTEXPR         CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
       : m_commandPool( commandPool )
     {}
@@ -29267,7 +29293,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_commandPool = VK_NULL_HANDLE;
+      m_commandPool = {};
       return *this;
     }
 
@@ -29306,7 +29332,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkCommandPool m_commandPool;
+    VkCommandPool m_commandPool = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ),
                  "handle and wrapper have different size!" );
@@ -29447,10 +29473,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
 
   public:
-    VULKAN_HPP_CONSTEXPR RenderPass() VULKAN_HPP_NOEXCEPT : m_renderPass( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_renderPass( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         RenderPass() = default;
+    VULKAN_HPP_CONSTEXPR         RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass )
     {}
 
@@ -29464,7 +29488,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_renderPass = VK_NULL_HANDLE;
+      m_renderPass = {};
       return *this;
     }
 
@@ -29503,7 +29527,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkRenderPass m_renderPass;
+    VkRenderPass m_renderPass = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ),
                  "handle and wrapper have different size!" );
@@ -29545,10 +29569,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
 
   public:
-    VULKAN_HPP_CONSTEXPR Framebuffer() VULKAN_HPP_NOEXCEPT : m_framebuffer( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_framebuffer( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Framebuffer() = default;
+    VULKAN_HPP_CONSTEXPR         Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
       : m_framebuffer( framebuffer )
     {}
@@ -29563,7 +29585,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_framebuffer = VK_NULL_HANDLE;
+      m_framebuffer = {};
       return *this;
     }
 
@@ -29602,7 +29624,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkFramebuffer m_framebuffer;
+    VkFramebuffer m_framebuffer = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ),
                  "handle and wrapper have different size!" );
@@ -30448,10 +30470,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
 
   public:
-    VULKAN_HPP_CONSTEXPR QueryPool() VULKAN_HPP_NOEXCEPT : m_queryPool( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_queryPool( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         QueryPool() = default;
+    VULKAN_HPP_CONSTEXPR         QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -30464,7 +30484,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_queryPool = VK_NULL_HANDLE;
+      m_queryPool = {};
       return *this;
     }
 
@@ -30503,7 +30523,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkQueryPool m_queryPool;
+    VkQueryPool m_queryPool = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ),
                  "handle and wrapper have different size!" );
@@ -30765,10 +30785,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
 
   public:
-    VULKAN_HPP_CONSTEXPR VideoSessionKHR() VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         VideoSessionKHR() = default;
+    VULKAN_HPP_CONSTEXPR         VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
       : m_videoSessionKHR( videoSessionKHR )
     {}
@@ -30783,7 +30801,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_videoSessionKHR = VK_NULL_HANDLE;
+      m_videoSessionKHR = {};
       return *this;
     }
 
@@ -30822,7 +30840,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkVideoSessionKHR m_videoSessionKHR;
+    VkVideoSessionKHR m_videoSessionKHR = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ),
                  "handle and wrapper have different size!" );
@@ -30859,13 +30877,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
 
   public:
-    VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT : m_videoSessionParametersKHR( VK_NULL_HANDLE )
-    {}
-
-    VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_videoSessionParametersKHR( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;
+    VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT
       VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
       : m_videoSessionParametersKHR( videoSessionParametersKHR )
@@ -30881,7 +30894,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_videoSessionParametersKHR = VK_NULL_HANDLE;
+      m_videoSessionParametersKHR = {};
       return *this;
     }
 
@@ -30920,7 +30933,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkVideoSessionParametersKHR m_videoSessionParametersKHR;
+    VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) == sizeof( VkVideoSessionParametersKHR ),
                  "handle and wrapper have different size!" );
@@ -30956,10 +30969,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
 
   public:
-    VULKAN_HPP_CONSTEXPR ImageView() VULKAN_HPP_NOEXCEPT : m_imageView( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_imageView( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         ImageView() = default;
+    VULKAN_HPP_CONSTEXPR         ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -30972,7 +30983,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_imageView = VK_NULL_HANDLE;
+      m_imageView = {};
       return *this;
     }
 
@@ -31011,7 +31022,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkImageView m_imageView;
+    VkImageView m_imageView = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ),
                  "handle and wrapper have different size!" );
@@ -31413,10 +31424,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
 
   public:
-    VULKAN_HPP_CONSTEXPR PipelineLayout() VULKAN_HPP_NOEXCEPT : m_pipelineLayout( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         PipelineLayout() = default;
+    VULKAN_HPP_CONSTEXPR         PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
       : m_pipelineLayout( pipelineLayout )
     {}
@@ -31431,7 +31440,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_pipelineLayout = VK_NULL_HANDLE;
+      m_pipelineLayout = {};
       return *this;
     }
 
@@ -31470,7 +31479,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkPipelineLayout m_pipelineLayout;
+    VkPipelineLayout m_pipelineLayout = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ),
                  "handle and wrapper have different size!" );
@@ -31512,10 +31521,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
 
   public:
-    VULKAN_HPP_CONSTEXPR DescriptorSet() VULKAN_HPP_NOEXCEPT : m_descriptorSet( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         DescriptorSet() = default;
+    VULKAN_HPP_CONSTEXPR         DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
       : m_descriptorSet( descriptorSet )
     {}
@@ -31530,7 +31537,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_descriptorSet = VK_NULL_HANDLE;
+      m_descriptorSet = {};
       return *this;
     }
 
@@ -31569,7 +31576,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDescriptorSet m_descriptorSet;
+    VkDescriptorSet m_descriptorSet = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ),
                  "handle and wrapper have different size!" );
@@ -31611,10 +31618,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
 
   public:
-    VULKAN_HPP_CONSTEXPR Pipeline() VULKAN_HPP_NOEXCEPT : m_pipeline( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_pipeline( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Pipeline() = default;
+    VULKAN_HPP_CONSTEXPR         Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -31627,7 +31632,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_pipeline = VK_NULL_HANDLE;
+      m_pipeline = {};
       return *this;
     }
 
@@ -31666,7 +31671,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkPipeline m_pipeline;
+    VkPipeline m_pipeline = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ),
                  "handle and wrapper have different size!" );
@@ -33696,13 +33701,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
 
   public:
-    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT : m_indirectCommandsLayoutNV( VK_NULL_HANDLE )
-    {}
-
-    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_indirectCommandsLayoutNV( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default;
+    VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT
       IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
       : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
@@ -33718,7 +33718,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_indirectCommandsLayoutNV = VK_NULL_HANDLE;
+      m_indirectCommandsLayoutNV = {};
       return *this;
     }
 
@@ -33757,7 +33757,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV;
+    VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ),
                  "handle and wrapper have different size!" );
@@ -34806,10 +34806,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
 
   public:
-    VULKAN_HPP_CONSTEXPR Sampler() VULKAN_HPP_NOEXCEPT : m_sampler( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_sampler( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Sampler() = default;
+    VULKAN_HPP_CONSTEXPR         Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -34822,7 +34820,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_sampler = VK_NULL_HANDLE;
+      m_sampler = {};
       return *this;
     }
 
@@ -34861,7 +34859,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkSampler m_sampler;
+    VkSampler m_sampler = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ),
                  "handle and wrapper have different size!" );
@@ -35059,10 +35057,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
 
   public:
-    VULKAN_HPP_CONSTEXPR BufferView() VULKAN_HPP_NOEXCEPT : m_bufferView( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_bufferView( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         BufferView() = default;
+    VULKAN_HPP_CONSTEXPR         BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView )
     {}
 
@@ -35076,7 +35072,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_bufferView = VK_NULL_HANDLE;
+      m_bufferView = {};
       return *this;
     }
 
@@ -35115,7 +35111,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkBufferView m_bufferView;
+    VkBufferView m_bufferView = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ),
                  "handle and wrapper have different size!" );
@@ -35373,13 +35369,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
 
   public:
-    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT : m_descriptorUpdateTemplate( VK_NULL_HANDLE )
-    {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_descriptorUpdateTemplate( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default;
+    VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT
       DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
       : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
@@ -35395,7 +35386,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_descriptorUpdateTemplate = VK_NULL_HANDLE;
+      m_descriptorUpdateTemplate = {};
       return *this;
     }
 
@@ -35434,7 +35425,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDescriptorUpdateTemplate m_descriptorUpdateTemplate;
+    VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ),
                  "handle and wrapper have different size!" );
@@ -35477,10 +35468,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
 
   public:
-    VULKAN_HPP_CONSTEXPR Event() VULKAN_HPP_NOEXCEPT : m_event( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_event( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Event() = default;
+    VULKAN_HPP_CONSTEXPR         Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -35493,7 +35482,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_event = VK_NULL_HANDLE;
+      m_event = {};
       return *this;
     }
 
@@ -35532,7 +35521,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkEvent m_event;
+    VkEvent m_event = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ),
                  "handle and wrapper have different size!" );
@@ -36658,10 +36647,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
 
   public:
-    VULKAN_HPP_CONSTEXPR CommandBuffer() VULKAN_HPP_NOEXCEPT : m_commandBuffer( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         CommandBuffer() = default;
+    VULKAN_HPP_CONSTEXPR         CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
       : m_commandBuffer( commandBuffer )
     {}
@@ -36676,7 +36663,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_commandBuffer = VK_NULL_HANDLE;
+      m_commandBuffer = {};
       return *this;
     }
 
@@ -37690,6 +37677,10 @@ namespace VULKAN_HPP_NAMESPACE
                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setDepthBounds( float            minDepthBounds,
                          float            maxDepthBounds,
                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
@@ -37795,6 +37786,15 @@ namespace VULKAN_HPP_NAMESPACE
                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
+                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void
+      setPatchControlPointsEXT( uint32_t         patchControlPoints,
+                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(
       const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
@@ -37828,11 +37828,21 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void
       setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
+      VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setRayTracingPipelineStackSizeKHR( uint32_t         pipelineStackSize,
                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
       VULKAN_HPP_NOEXCEPT;
@@ -38168,7 +38178,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkCommandBuffer m_commandBuffer;
+    VkCommandBuffer m_commandBuffer = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ),
                  "handle and wrapper have different size!" );
@@ -38387,10 +38397,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
 
   public:
-    VULKAN_HPP_CONSTEXPR ShaderModule() VULKAN_HPP_NOEXCEPT : m_shaderModule( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_shaderModule( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         ShaderModule() = default;
+    VULKAN_HPP_CONSTEXPR         ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
       : m_shaderModule( shaderModule )
     {}
@@ -38405,7 +38413,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_shaderModule = VK_NULL_HANDLE;
+      m_shaderModule = {};
       return *this;
     }
 
@@ -38444,7 +38452,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkShaderModule m_shaderModule;
+    VkShaderModule m_shaderModule = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ),
                  "handle and wrapper have different size!" );
@@ -40999,10 +41007,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
 
   public:
-    VULKAN_HPP_CONSTEXPR DescriptorPool() VULKAN_HPP_NOEXCEPT : m_descriptorPool( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         DescriptorPool() = default;
+    VULKAN_HPP_CONSTEXPR         DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
       : m_descriptorPool( descriptorPool )
     {}
@@ -41017,7 +41023,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_descriptorPool = VK_NULL_HANDLE;
+      m_descriptorPool = {};
       return *this;
     }
 
@@ -41056,7 +41062,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDescriptorPool m_descriptorPool;
+    VkDescriptorPool m_descriptorPool = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ),
                  "handle and wrapper have different size!" );
@@ -41098,12 +41104,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
 
   public:
-    VULKAN_HPP_CONSTEXPR DescriptorSetLayout() VULKAN_HPP_NOEXCEPT : m_descriptorSetLayout( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_descriptorSetLayout( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR         DescriptorSetLayout() = default;
+    VULKAN_HPP_CONSTEXPR         DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
       : m_descriptorSetLayout( descriptorSetLayout )
     {}
@@ -41118,7 +41120,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_descriptorSetLayout = VK_NULL_HANDLE;
+      m_descriptorSetLayout = {};
       return *this;
     }
 
@@ -41157,7 +41159,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDescriptorSetLayout m_descriptorSetLayout;
+    VkDescriptorSetLayout m_descriptorSetLayout = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ),
                  "handle and wrapper have different size!" );
@@ -43631,10 +43633,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
 
   public:
-    VULKAN_HPP_CONSTEXPR DisplayKHR() VULKAN_HPP_NOEXCEPT : m_displayKHR( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_displayKHR( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         DisplayKHR() = default;
+    VULKAN_HPP_CONSTEXPR         DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR )
     {}
 
@@ -43648,7 +43648,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_displayKHR = VK_NULL_HANDLE;
+      m_displayKHR = {};
       return *this;
     }
 
@@ -43687,7 +43687,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDisplayKHR m_displayKHR;
+    VkDisplayKHR m_displayKHR = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ),
                  "handle and wrapper have different size!" );
@@ -43817,14 +43817,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
 
   public:
-    VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT
-      : m_performanceConfigurationINTEL( VK_NULL_HANDLE )
-    {}
-
-    VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_performanceConfigurationINTEL( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default;
+    VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT
       PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
       : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
@@ -43841,7 +43835,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_performanceConfigurationINTEL = VK_NULL_HANDLE;
+      m_performanceConfigurationINTEL = {};
       return *this;
     }
 
@@ -43880,7 +43874,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL;
+    VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) ==
                    sizeof( VkPerformanceConfigurationINTEL ),
@@ -44110,12 +44104,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
 
   public:
-    VULKAN_HPP_CONSTEXPR DeferredOperationKHR() VULKAN_HPP_NOEXCEPT : m_deferredOperationKHR( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_deferredOperationKHR( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR         DeferredOperationKHR() = default;
+    VULKAN_HPP_CONSTEXPR         DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
       : m_deferredOperationKHR( deferredOperationKHR )
     {}
@@ -44130,7 +44120,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_deferredOperationKHR = VK_NULL_HANDLE;
+      m_deferredOperationKHR = {};
       return *this;
     }
 
@@ -44169,7 +44159,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDeferredOperationKHR m_deferredOperationKHR;
+    VkDeferredOperationKHR m_deferredOperationKHR = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ),
                  "handle and wrapper have different size!" );
@@ -44204,10 +44194,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
 
   public:
-    VULKAN_HPP_CONSTEXPR PipelineCache() VULKAN_HPP_NOEXCEPT : m_pipelineCache( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         PipelineCache() = default;
+    VULKAN_HPP_CONSTEXPR         PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
       : m_pipelineCache( pipelineCache )
     {}
@@ -44222,7 +44210,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_pipelineCache = VK_NULL_HANDLE;
+      m_pipelineCache = {};
       return *this;
     }
 
@@ -44261,7 +44249,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkPipelineCache m_pipelineCache;
+    VkPipelineCache m_pipelineCache = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ),
                  "handle and wrapper have different size!" );
@@ -47860,12 +47848,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
 
   public:
-    VULKAN_HPP_CONSTEXPR PrivateDataSlotEXT() VULKAN_HPP_NOEXCEPT : m_privateDataSlotEXT( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR PrivateDataSlotEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_privateDataSlotEXT( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR         PrivateDataSlotEXT() = default;
+    VULKAN_HPP_CONSTEXPR         PrivateDataSlotEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlotEXT( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT
       : m_privateDataSlotEXT( privateDataSlotEXT )
     {}
@@ -47880,7 +47864,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     PrivateDataSlotEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_privateDataSlotEXT = VK_NULL_HANDLE;
+      m_privateDataSlotEXT = {};
       return *this;
     }
 
@@ -47919,7 +47903,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkPrivateDataSlotEXT m_privateDataSlotEXT;
+    VkPrivateDataSlotEXT m_privateDataSlotEXT = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ),
                  "handle and wrapper have different size!" );
@@ -50517,12 +50501,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
 
   public:
-    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT : m_samplerYcbcrConversion( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_samplerYcbcrConversion( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;
+    VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT
       SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
       : m_samplerYcbcrConversion( samplerYcbcrConversion )
@@ -50538,7 +50518,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_samplerYcbcrConversion = VK_NULL_HANDLE;
+      m_samplerYcbcrConversion = {};
       return *this;
     }
 
@@ -50577,7 +50557,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkSamplerYcbcrConversion m_samplerYcbcrConversion;
+    VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ),
                  "handle and wrapper have different size!" );
@@ -50811,10 +50791,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
 
   public:
-    VULKAN_HPP_CONSTEXPR SurfaceKHR() VULKAN_HPP_NOEXCEPT : m_surfaceKHR( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         SurfaceKHR() = default;
+    VULKAN_HPP_CONSTEXPR         SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR )
     {}
 
@@ -50828,7 +50806,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_surfaceKHR = VK_NULL_HANDLE;
+      m_surfaceKHR = {};
       return *this;
     }
 
@@ -50867,7 +50845,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkSurfaceKHR m_surfaceKHR;
+    VkSurfaceKHR m_surfaceKHR = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ),
                  "handle and wrapper have different size!" );
@@ -51303,12 +51281,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
 
   public:
-    VULKAN_HPP_CONSTEXPR ValidationCacheEXT() VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_validationCacheEXT( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR         ValidationCacheEXT() = default;
+    VULKAN_HPP_CONSTEXPR         ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
       : m_validationCacheEXT( validationCacheEXT )
     {}
@@ -51323,7 +51297,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_validationCacheEXT = VK_NULL_HANDLE;
+      m_validationCacheEXT = {};
       return *this;
     }
 
@@ -51362,7 +51336,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkValidationCacheEXT m_validationCacheEXT;
+    VkValidationCacheEXT m_validationCacheEXT = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ),
                  "handle and wrapper have different size!" );
@@ -53013,10 +52987,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
 
   public:
-    VULKAN_HPP_CONSTEXPR Queue() VULKAN_HPP_NOEXCEPT : m_queue( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_queue( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Queue() = default;
+    VULKAN_HPP_CONSTEXPR         Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -53029,7 +53001,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_queue = VK_NULL_HANDLE;
+      m_queue = {};
       return *this;
     }
 
@@ -53203,7 +53175,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkQueue m_queue;
+    VkQueue m_queue = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ),
                  "handle and wrapper have different size!" );
@@ -57573,10 +57545,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
 
   public:
-    VULKAN_HPP_CONSTEXPR Device() VULKAN_HPP_NOEXCEPT : m_device( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_device( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Device() = default;
+    VULKAN_HPP_CONSTEXPR         Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -57589,7 +57559,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_device = VK_NULL_HANDLE;
+      m_device = {};
       return *this;
     }
 
@@ -61711,7 +61681,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDevice m_device;
+    VkDevice m_device = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ),
                  "handle and wrapper have different size!" );
@@ -61911,10 +61881,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
 
   public:
-    VULKAN_HPP_CONSTEXPR DisplayModeKHR() VULKAN_HPP_NOEXCEPT : m_displayModeKHR( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         DisplayModeKHR() = default;
+    VULKAN_HPP_CONSTEXPR         DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
       : m_displayModeKHR( displayModeKHR )
     {}
@@ -61929,7 +61897,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_displayModeKHR = VK_NULL_HANDLE;
+      m_displayModeKHR = {};
       return *this;
     }
 
@@ -61968,7 +61936,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDisplayModeKHR m_displayModeKHR;
+    VkDisplayModeKHR m_displayModeKHR = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ),
                  "handle and wrapper have different size!" );
@@ -66421,10 +66389,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
 
   public:
-    VULKAN_HPP_CONSTEXPR PhysicalDevice() VULKAN_HPP_NOEXCEPT : m_physicalDevice( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         PhysicalDevice() = default;
+    VULKAN_HPP_CONSTEXPR         PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
       : m_physicalDevice( physicalDevice )
     {}
@@ -66439,7 +66405,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_physicalDevice = VK_NULL_HANDLE;
+      m_physicalDevice = {};
       return *this;
     }
 
@@ -67782,7 +67748,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkPhysicalDevice m_physicalDevice;
+    VkPhysicalDevice m_physicalDevice = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ),
                  "handle and wrapper have different size!" );
@@ -77688,6 +77654,115 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExclusiveScissorFeaturesNV;
   };
 
+  struct PhysicalDeviceExtendedDynamicState2FeaturesEXT
+  {
+    static const bool                    allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState2FeaturesEXT(
+      VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2_                   = {},
+      VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2LogicOp_            = {},
+      VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2PatchControlPoints_ = {} ) VULKAN_HPP_NOEXCEPT
+      : extendedDynamicState2( extendedDynamicState2_ )
+      , extendedDynamicState2LogicOp( extendedDynamicState2LogicOp_ )
+      , extendedDynamicState2PatchControlPoints( extendedDynamicState2PatchControlPoints_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState2FeaturesEXT(
+      PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs )
+      VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceExtendedDynamicState2FeaturesEXT(
+          *reinterpret_cast<PhysicalDeviceExtendedDynamicState2FeaturesEXT const *>( &rhs ) )
+    {}
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT &
+                            operator=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT &
+      operator=( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const *>( &rhs );
+      return *this;
+    }
+
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT &
+      setExtendedDynamicState2( VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2_ ) VULKAN_HPP_NOEXCEPT
+    {
+      extendedDynamicState2 = extendedDynamicState2_;
+      return *this;
+    }
+
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT &
+      setExtendedDynamicState2LogicOp( VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2LogicOp_ ) VULKAN_HPP_NOEXCEPT
+    {
+      extendedDynamicState2LogicOp = extendedDynamicState2LogicOp_;
+      return *this;
+    }
+
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT & setExtendedDynamicState2PatchControlPoints(
+      VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState2PatchControlPoints_ ) VULKAN_HPP_NOEXCEPT
+    {
+      extendedDynamicState2PatchControlPoints = extendedDynamicState2PatchControlPoints_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>( this );
+    }
+
+    operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( extendedDynamicState2 == rhs.extendedDynamicState2 ) &&
+             ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) &&
+             ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints );
+    }
+
+    bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT;
+    void *                              pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32        extendedDynamicState2                   = {};
+    VULKAN_HPP_NAMESPACE::Bool32        extendedDynamicState2LogicOp            = {};
+    VULKAN_HPP_NAMESPACE::Bool32        extendedDynamicState2PatchControlPoints = {};
+  };
+  static_assert( sizeof( PhysicalDeviceExtendedDynamicState2FeaturesEXT ) ==
+                   sizeof( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceExtendedDynamicState2FeaturesEXT>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT>
+  {
+    using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT;
+  };
+
   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT
   {
     static const bool                    allowDuplicate = false;
@@ -99231,12 +99306,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
 
   public:
-    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT : m_debugReportCallbackEXT( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_debugReportCallbackEXT( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default;
+    VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT
       DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
       : m_debugReportCallbackEXT( debugReportCallbackEXT )
@@ -99252,7 +99323,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_debugReportCallbackEXT = VK_NULL_HANDLE;
+      m_debugReportCallbackEXT = {};
       return *this;
     }
 
@@ -99291,7 +99362,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDebugReportCallbackEXT m_debugReportCallbackEXT;
+    VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ),
                  "handle and wrapper have different size!" );
@@ -99333,12 +99404,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
 
   public:
-    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT : m_debugUtilsMessengerEXT( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
-      : m_debugUtilsMessengerEXT( VK_NULL_HANDLE )
-    {}
-
+    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;
+    VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT
       DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
       : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
@@ -99354,7 +99421,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_debugUtilsMessengerEXT = VK_NULL_HANDLE;
+      m_debugUtilsMessengerEXT = {};
       return *this;
     }
 
@@ -99393,7 +99460,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT;
+    VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ),
                  "handle and wrapper have different size!" );
@@ -99453,10 +99520,8 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
 
   public:
-    VULKAN_HPP_CONSTEXPR Instance() VULKAN_HPP_NOEXCEPT : m_instance( VK_NULL_HANDLE ) {}
-
-    VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT : m_instance( VK_NULL_HANDLE ) {}
-
+    VULKAN_HPP_CONSTEXPR         Instance() = default;
+    VULKAN_HPP_CONSTEXPR         Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
     VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
 
 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
@@ -99469,7 +99534,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
-      m_instance = VK_NULL_HANDLE;
+      m_instance = {};
       return *this;
     }
 
@@ -100127,7 +100192,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   private:
-    VkInstance m_instance;
+    VkInstance m_instance = {};
   };
   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ),
                  "handle and wrapper have different size!" );
@@ -102423,6 +102488,13 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthBiasEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBiasEnable ) );
+  }
+
+  template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float            minDepthBounds,
                                                         float            maxDepthBounds,
                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
@@ -102611,6 +102683,20 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
+                                                       Dispatch const &              d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetLogicOpEXT( m_commandBuffer, static_cast<VkLogicOp>( logicOp ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t         patchControlPoints,
+                                                                  Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetPatchControlPointsEXT( m_commandBuffer, patchControlPoints );
+  }
+
+  template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL(
     const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
@@ -102673,6 +102759,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
+    CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
+                                                 Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetPrimitiveRestartEnableEXT( m_commandBuffer, static_cast<VkBool32>( primitiveRestartEnable ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
     CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
                                             Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
   {
@@ -102681,6 +102775,14 @@ namespace VULKAN_HPP_NAMESPACE
 
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
+    CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
+                                                  Dispatch const &             d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetRasterizerDiscardEnableEXT( m_commandBuffer, static_cast<VkBool32>( rasterizerDiscardEnable ) );
+  }
+
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
     CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t         pipelineStackSize,
                                                       Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
@@ -119011,6 +119113,22 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
   {
     enum
@@ -121515,6 +121633,7 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCmdSetColorWriteEnableEXT                   vkCmdSetColorWriteEnableEXT                   = 0;
     PFN_vkCmdSetCullModeEXT                           vkCmdSetCullModeEXT                           = 0;
     PFN_vkCmdSetDepthBias                             vkCmdSetDepthBias                             = 0;
+    PFN_vkCmdSetDepthBiasEnableEXT                    vkCmdSetDepthBiasEnableEXT                    = 0;
     PFN_vkCmdSetDepthBounds                           vkCmdSetDepthBounds                           = 0;
     PFN_vkCmdSetDepthBoundsTestEnableEXT              vkCmdSetDepthBoundsTestEnableEXT              = 0;
     PFN_vkCmdSetDepthCompareOpEXT                     vkCmdSetDepthCompareOpEXT                     = 0;
@@ -121531,10 +121650,14 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCmdSetFrontFaceEXT                          vkCmdSetFrontFaceEXT                          = 0;
     PFN_vkCmdSetLineStippleEXT                        vkCmdSetLineStippleEXT                        = 0;
     PFN_vkCmdSetLineWidth                             vkCmdSetLineWidth                             = 0;
+    PFN_vkCmdSetLogicOpEXT                            vkCmdSetLogicOpEXT                            = 0;
+    PFN_vkCmdSetPatchControlPointsEXT                 vkCmdSetPatchControlPointsEXT                 = 0;
     PFN_vkCmdSetPerformanceMarkerINTEL                vkCmdSetPerformanceMarkerINTEL                = 0;
     PFN_vkCmdSetPerformanceOverrideINTEL              vkCmdSetPerformanceOverrideINTEL              = 0;
     PFN_vkCmdSetPerformanceStreamMarkerINTEL          vkCmdSetPerformanceStreamMarkerINTEL          = 0;
+    PFN_vkCmdSetPrimitiveRestartEnableEXT             vkCmdSetPrimitiveRestartEnableEXT             = 0;
     PFN_vkCmdSetPrimitiveTopologyEXT                  vkCmdSetPrimitiveTopologyEXT                  = 0;
+    PFN_vkCmdSetRasterizerDiscardEnableEXT            vkCmdSetRasterizerDiscardEnableEXT            = 0;
     PFN_vkCmdSetRayTracingPipelineStackSizeKHR        vkCmdSetRayTracingPipelineStackSizeKHR        = 0;
     PFN_vkCmdSetSampleLocationsEXT                    vkCmdSetSampleLocationsEXT                    = 0;
     PFN_vkCmdSetScissor                               vkCmdSetScissor                               = 0;
@@ -122119,7 +122242,7 @@ namespace VULKAN_HPP_NAMESPACE
     // This interface does not require a linked vulkan library.
     DispatchLoaderDynamic( VkInstance                instance,
                            PFN_vkGetInstanceProcAddr getInstanceProcAddr,
-                           VkDevice                  device            = VK_NULL_HANDLE,
+                           VkDevice                  device            = {},
                            PFN_vkGetDeviceProcAddr   getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT
     {
       init( instance, getInstanceProcAddr, device, getDeviceProcAddr );
@@ -122128,7 +122251,7 @@ namespace VULKAN_HPP_NAMESPACE
     // This interface does not require a linked vulkan library.
     void init( VkInstance                instance,
                PFN_vkGetInstanceProcAddr getInstanceProcAddr,
-               VkDevice                  device              = VK_NULL_HANDLE,
+               VkDevice                  device              = {},
                PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT
     {
       VULKAN_HPP_ASSERT( instance && getInstanceProcAddr );
@@ -122618,6 +122741,8 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) );
       vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) );
       vkCmdSetDepthBias   = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) );
+      vkCmdSetDepthBiasEnableEXT =
+        PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) );
       vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) );
       vkCmdSetDepthBoundsTestEnableEXT =
         PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) );
@@ -122644,15 +122769,22 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) );
       vkCmdSetLineStippleEXT =
         PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
-      vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
+      vkCmdSetLineWidth  = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
+      vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) );
+      vkCmdSetPatchControlPointsEXT =
+        PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) );
       vkCmdSetPerformanceMarkerINTEL =
         PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) );
       vkCmdSetPerformanceOverrideINTEL =
         PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) );
       vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL(
         vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
+      vkCmdSetPrimitiveRestartEnableEXT =
+        PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) );
       vkCmdSetPrimitiveTopologyEXT =
         PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) );
+      vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT(
+        vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) );
       vkCmdSetRayTracingPipelineStackSizeKHR = PFN_vkCmdSetRayTracingPipelineStackSizeKHR(
         vkGetInstanceProcAddr( instance, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
       vkCmdSetSampleLocationsEXT =
@@ -123338,6 +123470,8 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) );
       vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) );
       vkCmdSetDepthBias   = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
+      vkCmdSetDepthBiasEnableEXT =
+        PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) );
       vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
       vkCmdSetDepthBoundsTestEnableEXT =
         PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) );
@@ -123364,14 +123498,21 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdSetFrontFaceEXT   = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) );
       vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
       vkCmdSetLineWidth      = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
+      vkCmdSetLogicOpEXT     = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) );
+      vkCmdSetPatchControlPointsEXT =
+        PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) );
       vkCmdSetPerformanceMarkerINTEL =
         PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) );
       vkCmdSetPerformanceOverrideINTEL =
         PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) );
       vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL(
         vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
+      vkCmdSetPrimitiveRestartEnableEXT =
+        PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) );
       vkCmdSetPrimitiveTopologyEXT =
         PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) );
+      vkCmdSetRasterizerDiscardEnableEXT =
+        PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) );
       vkCmdSetRayTracingPipelineStackSizeKHR = PFN_vkCmdSetRayTracingPipelineStackSizeKHR(
         vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
       vkCmdSetSampleLocationsEXT =
diff --git a/include/vulkan/vulkan_beta.h b/include/vulkan/vulkan_beta.h
index 35d78b2..9aebb1a 100644
--- a/include/vulkan/vulkan_beta.h
+++ b/include/vulkan/vulkan_beta.h
@@ -370,7 +370,7 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
 
 
 #define VK_KHR_video_encode_queue 1
-#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 1
+#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 2
 #define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
 
 typedef enum VkVideoEncodeFlagBitsKHR {
diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 96df995..3b4fe62 100644
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -36,7 +36,7 @@ extern "C" {
 
 #ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
     #if (VK_USE_64_BIT_PTR_DEFINES==1)
-        #if __cplusplus >= 201103L
+        #if __cplusplus >= 201103L || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L))
             #define VK_NULL_HANDLE nullptr
         #else
             #define VK_NULL_HANDLE ((void*)0)
@@ -72,7 +72,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 175
+#define VK_HEADER_VERSION 176
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)
@@ -814,6 +814,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002,
     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000,
     VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000,
     VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000,
     VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001,
@@ -1543,6 +1544,11 @@ typedef enum VkDynamicState {
     VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010,
     VK_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011,
     VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000,
+    VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000,
+    VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = 1000377001,
+    VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = 1000377002,
+    VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,
+    VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = 1000377004,
     VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,
     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
 } VkDynamicState;
@@ -8254,7 +8260,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(
 
 #define VK_EXT_debug_report 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
-#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  9
+#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  10
 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
 
 typedef enum VkDebugReportObjectTypeEXT {
@@ -10378,7 +10384,7 @@ typedef struct VkPipelineCompilerControlCreateInfoAMD {
 
 
 #define VK_EXT_calibrated_timestamps 1
-#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1
+#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2
 #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
 
 typedef enum VkTimeDomainEXT {
@@ -11985,7 +11991,7 @@ typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
 
 
 #define VK_QCOM_rotated_copy_commands 1
-#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 0
+#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1
 #define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands"
 typedef struct VkCopyCommandTransformInfoQCOM {
     VkStructureType                  sType;
@@ -12098,6 +12104,46 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(
 #endif
 
 
+#define VK_EXT_extended_dynamic_state2 1
+#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1
+#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2"
+typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           extendedDynamicState2;
+    VkBool32           extendedDynamicState2LogicOp;
+    VkBool32           extendedDynamicState2PatchControlPoints;
+} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints);
+typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);
+typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp);
+typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    patchControlPoints);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    rasterizerDiscardEnable);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    depthBiasEnable);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkLogicOp                                   logicOp);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkBool32                                    primitiveRestartEnable);
+#endif
+
+
 #define VK_EXT_color_write_enable 1
 #define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1
 #define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable"
diff --git a/registry/validusage.json b/registry/validusage.json
index d0f40fc..e237aef 100644
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.2.175",
-    "comment": "from git branch: github-main commit: b82ae46bb82c7a522509fd7b8f3d92a311c1b5a5",
-    "date": "2021-04-13 08:38:27Z"
+    "api version": "1.2.176",
+    "comment": "from git branch: github-main commit: 67f599afee77b0e598e7a325f13b9878edcacdfd",
+    "date": "2021-04-19 04:31:54Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -564,7 +564,7 @@
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext",
-          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDeviceMemoryReportCreateInfoEXT\">VkDeviceDeviceMemoryReportCreateInfoEXT</a>, <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkDevicePrivateDataCreateInfoEXT\">VkDevicePrivateDataCreateInfoEXT</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice4444FormatsFeaturesEXT\">VkPhysicalDevice4444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceColorWriteEnableFeaturesEXT\">VkPhysicalDeviceColorWriteEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorFeaturesEXT\">VkPhysicalDeviceCustomBorderColorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceMemoryReportFeaturesEXT\">VkPhysicalDeviceDeviceMemoryReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicStateFeaturesEXT\">VkPhysicalDeviceExtendedDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2FeaturesEXT\">VkPhysicalDeviceFragmentDensityMap2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV\">VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateFeaturesKHR\">VkPhysicalDeviceFragmentShadingRateFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImageRobustnessFeaturesEXT\">VkPhysicalDeviceImageRobustnessFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesEXT\">VkPhysicalDeviceIndexTypeUint8FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInheritedViewportScissorFeaturesNV\">VkPhysicalDeviceInheritedViewportScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesEXT\">VkPhysicalDeviceLineRasterizationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE\">VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT\">VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetFeaturesKHR\">VkPhysicalDevicePortabilitySubsetFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePrivateDataFeaturesEXT\">VkPhysicalDevicePrivateDataFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRayQueryFeaturesKHR\">VkPhysicalDeviceRayQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelineFeaturesKHR\">VkPhysicalDeviceRayTracingPipelineFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2FeaturesEXT\">VkPhysicalDeviceRobustness2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloatFeaturesEXT\">VkPhysicalDeviceShaderAtomicFloatFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT\">VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR\">VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSynchronization2FeaturesKHR\">VkPhysicalDeviceSynchronization2FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT\">VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, <a href=\"#VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR\">VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT\">VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR\">VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR</a>"
+          "text": " Each <code>pNext</code> member of any structure (including this one) in the <code>pNext</code> chain <strong class=\"purple\">must</strong> be either <code>NULL</code> or a pointer to a valid instance of <a href=\"#VkDeviceDeviceMemoryReportCreateInfoEXT\">VkDeviceDeviceMemoryReportCreateInfoEXT</a>, <a href=\"#VkDeviceDiagnosticsConfigCreateInfoNV\">VkDeviceDiagnosticsConfigCreateInfoNV</a>, <a href=\"#VkDeviceGroupDeviceCreateInfo\">VkDeviceGroupDeviceCreateInfo</a>, <a href=\"#VkDeviceMemoryOverallocationCreateInfoAMD\">VkDeviceMemoryOverallocationCreateInfoAMD</a>, <a href=\"#VkDevicePrivateDataCreateInfoEXT\">VkDevicePrivateDataCreateInfoEXT</a>, <a href=\"#VkPhysicalDevice16BitStorageFeatures\">VkPhysicalDevice16BitStorageFeatures</a>, <a href=\"#VkPhysicalDevice4444FormatsFeaturesEXT\">VkPhysicalDevice4444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDevice8BitStorageFeatures\">VkPhysicalDevice8BitStorageFeatures</a>, <a href=\"#VkPhysicalDeviceASTCDecodeFeaturesEXT\">VkPhysicalDeviceASTCDecodeFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\">VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeatures\">VkPhysicalDeviceBufferDeviceAddressFeatures</a>, <a href=\"#VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\">VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCoherentMemoryFeaturesAMD\">VkPhysicalDeviceCoherentMemoryFeaturesAMD</a>, <a href=\"#VkPhysicalDeviceColorWriteEnableFeaturesEXT\">VkPhysicalDeviceColorWriteEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceComputeShaderDerivativesFeaturesNV\">VkPhysicalDeviceComputeShaderDerivativesFeaturesNV</a>, <a href=\"#VkPhysicalDeviceConditionalRenderingFeaturesEXT\">VkPhysicalDeviceConditionalRenderingFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceCooperativeMatrixFeaturesNV\">VkPhysicalDeviceCooperativeMatrixFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCornerSampledImageFeaturesNV\">VkPhysicalDeviceCornerSampledImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCoverageReductionModeFeaturesNV\">VkPhysicalDeviceCoverageReductionModeFeaturesNV</a>, <a href=\"#VkPhysicalDeviceCustomBorderColorFeaturesEXT\">VkPhysicalDeviceCustomBorderColorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\">VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDepthClipEnableFeaturesEXT\">VkPhysicalDeviceDepthClipEnableFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDescriptorIndexingFeatures\">VkPhysicalDeviceDescriptorIndexingFeatures</a>, <a href=\"#VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\">VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceDeviceMemoryReportFeaturesEXT\">VkPhysicalDeviceDeviceMemoryReportFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceDiagnosticsConfigFeaturesNV\">VkPhysicalDeviceDiagnosticsConfigFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExclusiveScissorFeaturesNV\">VkPhysicalDeviceExclusiveScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicState2FeaturesEXT\">VkPhysicalDeviceExtendedDynamicState2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceExtendedDynamicStateFeaturesEXT\">VkPhysicalDeviceExtendedDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFeatures2\">VkPhysicalDeviceFeatures2</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMap2FeaturesEXT\">VkPhysicalDeviceFragmentDensityMap2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentDensityMapFeaturesEXT\">VkPhysicalDeviceFragmentDensityMapFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV\">VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\">VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV\">VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceFragmentShadingRateFeaturesKHR\">VkPhysicalDeviceFragmentShadingRateFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceHostQueryResetFeatures\">VkPhysicalDeviceHostQueryResetFeatures</a>, <a href=\"#VkPhysicalDeviceImageRobustnessFeaturesEXT\">VkPhysicalDeviceImageRobustnessFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceImagelessFramebufferFeatures\">VkPhysicalDeviceImagelessFramebufferFeatures</a>, <a href=\"#VkPhysicalDeviceIndexTypeUint8FeaturesEXT\">VkPhysicalDeviceIndexTypeUint8FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceInheritedViewportScissorFeaturesNV\">VkPhysicalDeviceInheritedViewportScissorFeaturesNV</a>, <a href=\"#VkPhysicalDeviceInlineUniformBlockFeaturesEXT\">VkPhysicalDeviceInlineUniformBlockFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceLineRasterizationFeaturesEXT\">VkPhysicalDeviceLineRasterizationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMemoryPriorityFeaturesEXT\">VkPhysicalDeviceMemoryPriorityFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceMeshShaderFeaturesNV\">VkPhysicalDeviceMeshShaderFeaturesNV</a>, <a href=\"#VkPhysicalDeviceMultiviewFeatures\">VkPhysicalDeviceMultiviewFeatures</a>, <a href=\"#VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE\">VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE</a>, <a href=\"#VkPhysicalDevicePerformanceQueryFeaturesKHR\">VkPhysicalDevicePerformanceQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT\">VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT</a>, <a href=\"#VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\">VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePortabilitySubsetFeaturesKHR\">VkPhysicalDevicePortabilitySubsetFeaturesKHR</a>, <a href=\"#VkPhysicalDevicePrivateDataFeaturesEXT\">VkPhysicalDevicePrivateDataFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceProtectedMemoryFeatures\">VkPhysicalDeviceProtectedMemoryFeatures</a>, <a href=\"#VkPhysicalDeviceRayQueryFeaturesKHR\">VkPhysicalDeviceRayQueryFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRayTracingPipelineFeaturesKHR\">VkPhysicalDeviceRayTracingPipelineFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\">VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV</a>, <a href=\"#VkPhysicalDeviceRobustness2FeaturesEXT\">VkPhysicalDeviceRobustness2FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSamplerYcbcrConversionFeatures\">VkPhysicalDeviceSamplerYcbcrConversionFeatures</a>, <a href=\"#VkPhysicalDeviceScalarBlockLayoutFeatures\">VkPhysicalDeviceScalarBlockLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\">VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures</a>, <a href=\"#VkPhysicalDeviceShaderAtomicFloatFeaturesEXT\">VkPhysicalDeviceShaderAtomicFloatFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderAtomicInt64Features\">VkPhysicalDeviceShaderAtomicInt64Features</a>, <a href=\"#VkPhysicalDeviceShaderClockFeaturesKHR\">VkPhysicalDeviceShaderClockFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT\">VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderDrawParametersFeatures\">VkPhysicalDeviceShaderDrawParametersFeatures</a>, <a href=\"#VkPhysicalDeviceShaderFloat16Int8Features\">VkPhysicalDeviceShaderFloat16Int8Features</a>, <a href=\"#VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT\">VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT</a>, <a href=\"#VkPhysicalDeviceShaderImageFootprintFeaturesNV\">VkPhysicalDeviceShaderImageFootprintFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\">VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL</a>, <a href=\"#VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\">VkPhysicalDeviceShaderSMBuiltinsFeaturesNV</a>, <a href=\"#VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\">VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures</a>, <a href=\"#VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR\">VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceShadingRateImageFeaturesNV\">VkPhysicalDeviceShadingRateImageFeaturesNV</a>, <a href=\"#VkPhysicalDeviceSubgroupSizeControlFeaturesEXT\">VkPhysicalDeviceSubgroupSizeControlFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceSynchronization2FeaturesKHR\">VkPhysicalDeviceSynchronization2FeaturesKHR</a>, <a href=\"#VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\">VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT\">VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceTimelineSemaphoreFeatures\">VkPhysicalDeviceTimelineSemaphoreFeatures</a>, <a href=\"#VkPhysicalDeviceTransformFeedbackFeaturesEXT\">VkPhysicalDeviceTransformFeedbackFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceUniformBufferStandardLayoutFeatures\">VkPhysicalDeviceUniformBufferStandardLayoutFeatures</a>, <a href=\"#VkPhysicalDeviceVariablePointersFeatures\">VkPhysicalDeviceVariablePointersFeatures</a>, <a href=\"#VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT\">VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT\">VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceVulkan11Features\">VkPhysicalDeviceVulkan11Features</a>, <a href=\"#VkPhysicalDeviceVulkan12Features\">VkPhysicalDeviceVulkan12Features</a>, <a href=\"#VkPhysicalDeviceVulkanMemoryModelFeatures\">VkPhysicalDeviceVulkanMemoryModelFeatures</a>, <a href=\"#VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR\">VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR</a>, <a href=\"#VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT\">VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT</a>, <a href=\"#VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\">VkPhysicalDeviceYcbcrImageArraysFeaturesEXT</a>, or <a href=\"#VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR\">VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR</a>"
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-sType-unique",
@@ -8288,6 +8288,30 @@
         }
       ]
     },
+    "vkCmdSetPatchControlPointsEXT": {
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdSetPatchControlPointsEXT-None-04873",
+          "text": " The <a href=\"#features-extendedDynamicState2PatchControlPoints\">extendedDynamicState2PatchControlPoints</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-vkCmdSetPatchControlPointsEXT-patchControlPoints-04874",
+          "text": " <code>patchControlPoints</code> <strong class=\"purple\">must</strong> be greater than zero and less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxTessellationPatchSize</code>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetPatchControlPointsEXT-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdSetPatchControlPointsEXT-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetPatchControlPointsEXT-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        }
+      ]
+    },
     "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV": {
       "(VK_NV_cooperative_matrix)": [
         {
@@ -8950,23 +8974,23 @@
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750",
-          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, <code>pViewportState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineViewportStateCreateInfo\">VkPipelineViewportStateCreateInfo</a> structure"
+          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>,"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751",
-          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, <code>pMultisampleState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineMultisampleStateCreateInfo\">VkPipelineMultisampleStateCreateInfo</a> structure"
+          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>,"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00752",
-          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, and <code>subpass</code> uses a depth/stencil attachment, <code>pDepthStencilState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineDepthStencilStateCreateInfo\">VkPipelineDepthStencilStateCreateInfo</a> structure"
+          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>,"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00753",
-          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, and <code>subpass</code> uses color attachments, <code>pColorBlendState</code> <strong class=\"purple\">must</strong> be a valid pointer to a valid <a href=\"#VkPipelineColorBlendStateCreateInfo\">VkPipelineColorBlendStateCreateInfo</a> structure"
+          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>,"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-04493",
-          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>, <code>pColorBlendState-&gt;attachmentCount</code> <strong class=\"purple\">must</strong> be greater than the index of all color attachments that are not <code>VK_ATTACHMENT_UNUSED</code> for the <code>subpass</code> index in <code>renderPass</code>"
+          "text": " If the <code>rasterizerDiscardEnable</code> member of <code>pRasterizationState</code> is <code>VK_FALSE</code>,"
         },
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00754",
@@ -9305,6 +9329,20 @@
           "text": " All elements of the <code>pDynamicStates</code> member of <code>pDynamicState</code> <strong class=\"purple\">must</strong> not be <code>VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR</code>"
         }
       ],
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04868",
+          "text": " If the <a href=\"#features-extendedDynamicState2\">extendedDynamicState2</a> feature is not enabled, there <strong class=\"purple\">must</strong> be no element of the <code>pDynamicStates</code> member of <code>pDynamicState</code> set to <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code>, <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code>, or <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code>"
+        },
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04869",
+          "text": " If the <a href=\"#features-extendedDynamicState2LogicOp\">extendedDynamicState2LogicOp</a> feature is not enabled, there <strong class=\"purple\">must</strong> be no element of the <code>pDynamicStates</code> member of <code>pDynamicState</code> set to <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code>"
+        },
+        {
+          "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04870",
+          "text": " If the <a href=\"#features-extendedDynamicState2PatchControlPoints\">extendedDynamicState2PatchControlPoints</a> feature is not enabled, there <strong class=\"purple\">must</strong> be no element of the <code>pDynamicStates</code> member of <code>pDynamicState</code> set to <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code>"
+        }
+      ],
       "(VK_NV_device_generated_commands)": [
         {
           "vuid": "VUID-VkGraphicsPipelineCreateInfo-flags-02877",
@@ -16200,7 +16238,7 @@
       "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)+(VK_KHR_acceleration_structure)": [
         {
           "vuid": "VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-descriptorBindingAccelerationStructureUpdateAfterBind-03570",
-          "text": " If <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>::<code>descriptorBindingAccelerationStructureUpdateAfterBind</code> is not enabled, all bindings with descriptor type <code>VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR</code> or <code>VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV</code> <strong class=\"purple\">must</strong> not use <code>VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT</code>"
+          "text": " If <a href=\"#VkPhysicalDeviceAccelerationStructureFeaturesKHR\">VkPhysicalDeviceAccelerationStructureFeaturesKHR</a>::<code>descriptorBindingAccelerationStructureUpdateAfterBind</code> is not enabled, all bindings with descriptor type <code>VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR</code>"
         }
       ]
     },
@@ -16536,7 +16574,7 @@
         },
         {
           "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03572",
-          "text": " The total number of bindings with a <code>descriptorType</code> of <code>VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR</code> to any given shader stage across all elements of <code>pSetLayouts</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceAccelerationStructurePropertiesKHR\">VkPhysicalDeviceAccelerationStructurePropertiesKHR</a>::<code>maxPerStageDescriptorUpdateAfterBindAccelerationStructures</code>"
+          "text": " The total number of bindings with a <code>descriptorType</code> of <code>VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR</code> accessible to any given shader stage across all elements of <code>pSetLayouts</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceAccelerationStructurePropertiesKHR\">VkPhysicalDeviceAccelerationStructurePropertiesKHR</a>::<code>maxPerStageDescriptorUpdateAfterBindAccelerationStructures</code>"
         },
         {
           "vuid": "VUID-VkPipelineLayoutCreateInfo-descriptorType-03573",
@@ -17252,7 +17290,7 @@
         },
         {
           "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureKHR-pAccelerationStructures-03580",
-          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, each member of <code>pAccelerationStructures</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
+          "text": " If the <a href=\"#features-nullDescriptor\">nullDescriptor</a> feature is not enabled, each element of <code>pAccelerationStructures</code> <strong class=\"purple\">must</strong> not be <a href=\"#VK_NULL_HANDLE\">VK_NULL_HANDLE</a>"
         },
         {
           "vuid": "VUID-VkWriteDescriptorSetAccelerationStructureKHR-sType-sType",
@@ -17500,11 +17538,11 @@
       "(VK_VERSION_1_1,VK_KHR_descriptor_update_template)": [
         {
           "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356",
-          "text": " If <code>VkAllocationCallbacks</code> were provided when <code>descriptorSetLayout</code> was created, a compatible set of callbacks <strong class=\"purple\">must</strong> be provided here"
+          "text": " If <code>VkAllocationCallbacks</code> were provided when <code>descriptorUpdateTemplate</code> was created, a compatible set of callbacks <strong class=\"purple\">must</strong> be provided here"
         },
         {
           "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357",
-          "text": " If no <code>VkAllocationCallbacks</code> were provided when <code>descriptorSetLayout</code> was created, <code>pAllocator</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
+          "text": " If no <code>VkAllocationCallbacks</code> were provided when <code>descriptorUpdateTemplate</code> was created, <code>pAllocator</code> <strong class=\"purple\">must</strong> be <code>NULL</code>"
         },
         {
           "vuid": "VUID-vkDestroyDescriptorUpdateTemplate-device-parameter",
@@ -17774,11 +17812,11 @@
       "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)": [
         {
           "vuid": "VUID-vkGetBufferDeviceAddress-bufferDeviceAddress-03324",
-          "text": " The <a href=\"#features-bufferDeviceAddress\">bufferDeviceAddress</a> or <a href=\"#features-bufferDeviceAddressEXT\"><code>VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</code>::<code>bufferDeviceAddress</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+          "text": " The <a href=\"#features-bufferDeviceAddress\">bufferDeviceAddress</a>"
         },
         {
           "vuid": "VUID-vkGetBufferDeviceAddress-device-03325",
-          "text": " If <code>device</code> was created with multiple physical devices, then the <a href=\"#features-bufferDeviceAddressMultiDevice\">bufferDeviceAddressMultiDevice</a> or <a href=\"#features-bufferDeviceAddressMultiDeviceEXT\"><code>VkPhysicalDeviceBufferDeviceAddressFeaturesEXT</code>::<code>bufferDeviceAddressMultiDevice</code></a> feature <strong class=\"purple\">must</strong> be enabled"
+          "text": " If <code>device</code> was created with multiple physical devices, then the <a href=\"#features-bufferDeviceAddressMultiDevice\">bufferDeviceAddressMultiDevice</a>"
         },
         {
           "vuid": "VUID-vkGetBufferDeviceAddress-device-parameter",
@@ -19955,10 +19993,6 @@
           "text": " <code>firstQuery</code> <strong class=\"purple\">must</strong> be less than the number of queries in <code>queryPool</code>"
         },
         {
-          "vuid": "VUID-vkGetQueryPoolResults-flags-02827",
-          "text": " If <code>VK_QUERY_RESULT_64_BIT</code> is not set in <code>flags</code>, then <code>pData</code> and <code>stride</code> <strong class=\"purple\">must</strong> be multiples of <code>4</code>"
-        },
-        {
           "vuid": "VUID-vkGetQueryPoolResults-flags-00815",
           "text": " If <code>VK_QUERY_RESULT_64_BIT</code> is set in <code>flags</code> then <code>pData</code> and <code>stride</code> <strong class=\"purple\">must</strong> be multiples of <code>8</code>"
         },
@@ -19999,6 +20033,12 @@
           "text": " <code>queryPool</code> <strong class=\"purple\">must</strong> have been created, allocated, or retrieved from <code>device</code>"
         }
       ],
+      "!(VK_KHR_performance_query)": [
+        {
+          "vuid": "VUID-vkGetQueryPoolResults-flags-02827",
+          "text": " If <code>VK_QUERY_RESULT_64_BIT</code> is not set in <code>flags</code>, then <code>pData</code> and <code>stride</code> <strong class=\"purple\">must</strong> be multiples of <code>4</code>"
+        }
+      ],
       "(VK_KHR_performance_query)": [
         {
           "vuid": "VUID-vkGetQueryPoolResults-flags-02828",
@@ -21554,11 +21594,11 @@
         },
         {
           "vuid": "VUID-vkCmdCopyImage-srcImage-04443",
-          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then for each element of <code>pRegions</code>, <code>srcSubresource.baseArrayLayer</code> <strong class=\"purple\">must</strong> be <code>0</code> and and <code>srcSubresource.layerCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then for each element of <code>pRegions</code>, <code>srcSubresource.baseArrayLayer</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcSubresource.layerCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-vkCmdCopyImage-dstImage-04444",
-          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then for each element of <code>pRegions</code>, <code>dstSubresource.baseArrayLayer</code> <strong class=\"purple\">must</strong> be <code>0</code> and and <code>dstSubresource.layerCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then for each element of <code>pRegions</code>, <code>dstSubresource.baseArrayLayer</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstSubresource.layerCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-vkCmdCopyImage-srcImage-01790",
@@ -21954,11 +21994,11 @@
         },
         {
           "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-04443",
-          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then for each element of <code>pRegions</code>, <code>srcSubresource.baseArrayLayer</code> <strong class=\"purple\">must</strong> be <code>0</code> and and <code>srcSubresource.layerCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then for each element of <code>pRegions</code>, <code>srcSubresource.baseArrayLayer</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcSubresource.layerCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-VkCopyImageInfo2KHR-dstImage-04444",
-          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then for each element of <code>pRegions</code>, <code>dstSubresource.baseArrayLayer</code> <strong class=\"purple\">must</strong> be <code>0</code> and and <code>dstSubresource.layerCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_3D</code>, then for each element of <code>pRegions</code>, <code>dstSubresource.baseArrayLayer</code> <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstSubresource.layerCount</code> <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-VkCopyImageInfo2KHR-srcImage-01790",
@@ -22182,7 +22222,7 @@
         },
         {
           "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-00198",
-          "text": " For each element of <code>pRegions</code>, <code>imageOffset.y</code> and <span class=\"eq\">(imageExtent.height &#43; <code>imageOffset.y</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>imageSubresource</code> of <code>dstImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>imageOffset.y</code> and <span class=\"eq\">(<code>imageExtent.height</code> &#43; <code>imageOffset.y</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>imageSubresource</code> of <code>dstImage</code>"
         },
         {
           "vuid": "VUID-vkCmdCopyBufferToImage-srcImage-00199",
@@ -22190,7 +22230,7 @@
         },
         {
           "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-00200",
-          "text": " For each element of <code>pRegions</code>, <code>imageOffset.z</code> and <span class=\"eq\">(imageExtent.depth &#43; <code>imageOffset.z</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>imageSubresource</code> of {imageparam}"
+          "text": " For each element of <code>pRegions</code>, <code>imageOffset.z</code> and <span class=\"eq\">(<code>imageExtent.depth</code> &#43; <code>imageOffset.z</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>imageSubresource</code> of {imageparam}"
         },
         {
           "vuid": "VUID-vkCmdCopyBufferToImage-srcImage-00201",
@@ -22418,7 +22458,7 @@
         },
         {
           "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-00200",
-          "text": " For each element of <code>pRegions</code>, <code>imageOffset.z</code> and <span class=\"eq\">(imageExtent.depth &#43; <code>imageOffset.z</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>imageSubresource</code> of {imageparam}"
+          "text": " For each element of <code>pRegions</code>, <code>imageOffset.z</code> and <span class=\"eq\">(<code>imageExtent.depth</code> &#43; <code>imageOffset.z</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>imageSubresource</code> of {imageparam}"
         },
         {
           "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-00201",
@@ -22708,7 +22748,7 @@
         },
         {
           "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageOffset-00200",
-          "text": " For each element of <code>pRegions</code>, <code>imageOffset.z</code> and <span class=\"eq\">(imageExtent.depth &#43; <code>imageOffset.z</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>imageSubresource</code> of {imageparam}"
+          "text": " For each element of <code>pRegions</code>, <code>imageOffset.z</code> and <span class=\"eq\">(<code>imageExtent.depth</code> &#43; <code>imageOffset.z</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>imageSubresource</code> of {imageparam}"
         },
         {
           "vuid": "VUID-VkCopyBufferToImageInfo2KHR-srcImage-00201",
@@ -22972,7 +23012,7 @@
         },
         {
           "vuid": "VUID-VkCopyImageToBufferInfo2KHR-imageOffset-00200",
-          "text": " For each element of <code>pRegions</code>, <code>imageOffset.z</code> and <span class=\"eq\">(imageExtent.depth &#43; <code>imageOffset.z</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>imageSubresource</code> of {imageparam}"
+          "text": " For each element of <code>pRegions</code>, <code>imageOffset.z</code> and <span class=\"eq\">(<code>imageExtent.depth</code> &#43; <code>imageOffset.z</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>imageSubresource</code> of {imageparam}"
         },
         {
           "vuid": "VUID-VkCopyImageToBufferInfo2KHR-srcImage-00201",
@@ -23270,43 +23310,43 @@
         },
         {
           "vuid": "VUID-vkCmdBlitImage-srcOffset-00243",
-          "text": " For each element of <code>pRegions</code>, <code>srcOffset</code>[0].x and <code>srcOffset</code>[1].x <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>srcSubresource</code> of <code>srcImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>srcOffsets</code>[0].x and <code>srcOffsets</code>[1].x <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>srcSubresource</code> of <code>srcImage</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-srcOffset-00244",
-          "text": " For each element of <code>pRegions</code>, <code>srcOffset</code>[0].y and <code>srcOffset</code>[1].y <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>srcSubresource</code> of <code>srcImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>srcOffsets</code>[0].y and <code>srcOffsets</code>[1].y <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>srcSubresource</code> of <code>srcImage</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-srcImage-00245",
-          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then for each element of <code>pRegions</code>, <code>srcOffset</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffset</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then for each element of <code>pRegions</code>, <code>srcOffsets</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffsets</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-srcOffset-00246",
-          "text": " For each element of <code>pRegions</code>, <code>srcOffset</code>[0].z and <code>srcOffset</code>[1].z <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>srcSubresource</code> of <code>srcImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>srcOffsets</code>[0].z and <code>srcOffsets</code>[1].z <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>srcSubresource</code> of <code>srcImage</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-srcImage-00247",
-          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then for each element of <code>pRegions</code>, <code>srcOffset</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffset</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then for each element of <code>pRegions</code>, <code>srcOffsets</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffsets</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-dstOffset-00248",
-          "text": " For each element of <code>pRegions</code>, <code>dstOffset</code>[0].x and <code>dstOffset</code>[1].x <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>dstSubresource</code> of <code>dstImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>dstOffsets</code>[0].x and <code>dstOffsets</code>[1].x <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>dstSubresource</code> of <code>dstImage</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-dstOffset-00249",
-          "text": " For each element of <code>pRegions</code>, <code>dstOffset</code>[0].y and <code>dstOffset</code>[1].y <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>dstSubresource</code> of <code>dstImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>dstOffsets</code>[0].y and <code>dstOffsets</code>[1].y <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>dstSubresource</code> of <code>dstImage</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-dstImage-00250",
-          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then for each element of <code>pRegions</code>, <code>dstOffset</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffset</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then for each element of <code>pRegions</code>, <code>dstOffsets</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffsets</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-dstOffset-00251",
-          "text": " For each element of <code>pRegions</code>, <code>dstOffset</code>[0].z and <code>dstOffset</code>[1].z <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>dstSubresource</code> of <code>dstImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>dstOffsets</code>[0].z and <code>dstOffsets</code>[1].z <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>dstSubresource</code> of <code>dstImage</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-dstImage-00252",
-          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then for each element of <code>pRegions</code>, <code>dstOffset</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffset</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then for each element of <code>pRegions</code>, <code>dstOffsets</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffsets</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-vkCmdBlitImage-commandBuffer-parameter",
@@ -23566,43 +23606,43 @@
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-srcOffset-00243",
-          "text": " For each element of <code>pRegions</code>, <code>srcOffset</code>[0].x and <code>srcOffset</code>[1].x <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>srcSubresource</code> of <code>srcImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>srcOffsets</code>[0].x and <code>srcOffsets</code>[1].x <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>srcSubresource</code> of <code>srcImage</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-srcOffset-00244",
-          "text": " For each element of <code>pRegions</code>, <code>srcOffset</code>[0].y and <code>srcOffset</code>[1].y <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>srcSubresource</code> of <code>srcImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>srcOffsets</code>[0].y and <code>srcOffsets</code>[1].y <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>srcSubresource</code> of <code>srcImage</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00245",
-          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then for each element of <code>pRegions</code>, <code>srcOffset</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffset</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then for each element of <code>pRegions</code>, <code>srcOffsets</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffsets</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-srcOffset-00246",
-          "text": " For each element of <code>pRegions</code>, <code>srcOffset</code>[0].z and <code>srcOffset</code>[1].z <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>srcSubresource</code> of <code>srcImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>srcOffsets</code>[0].z and <code>srcOffsets</code>[1].z <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>srcSubresource</code> of <code>srcImage</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-srcImage-00247",
-          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then for each element of <code>pRegions</code>, <code>srcOffset</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffset</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>srcImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then for each element of <code>pRegions</code>, <code>srcOffsets</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>srcOffsets</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-dstOffset-00248",
-          "text": " For each element of <code>pRegions</code>, <code>dstOffset</code>[0].x and <code>dstOffset</code>[1].x <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>dstSubresource</code> of <code>dstImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>dstOffsets</code>[0].x and <code>dstOffsets</code>[1].x <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>dstSubresource</code> of <code>dstImage</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-dstOffset-00249",
-          "text": " For each element of <code>pRegions</code>, <code>dstOffset</code>[0].y and <code>dstOffset</code>[1].y <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>dstSubresource</code> of <code>dstImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>dstOffsets</code>[0].y and <code>dstOffsets</code>[1].y <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>dstSubresource</code> of <code>dstImage</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-00250",
-          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then for each element of <code>pRegions</code>, <code>dstOffset</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffset</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code>, then for each element of <code>pRegions</code>, <code>dstOffsets</code>[0].y <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffsets</code>[1].y <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-dstOffset-00251",
-          "text": " For each element of <code>pRegions</code>, <code>dstOffset</code>[0].z and <code>dstOffset</code>[1].z <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>dstSubresource</code> of <code>dstImage</code>"
+          "text": " For each element of <code>pRegions</code>, <code>dstOffsets</code>[0].z and <code>dstOffsets</code>[1].z <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the depth of the specified <code>dstSubresource</code> of <code>dstImage</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-dstImage-00252",
-          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then for each element of <code>pRegions</code>, <code>dstOffset</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffset</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
+          "text": " If <code>dstImage</code> is of type <code>VK_IMAGE_TYPE_1D</code> or <code>VK_IMAGE_TYPE_2D</code>, then for each element of <code>pRegions</code>, <code>dstOffsets</code>[0].z <strong class=\"purple\">must</strong> be <code>0</code> and <code>dstOffsets</code>[1].z <strong class=\"purple\">must</strong> be <code>1</code>"
         },
         {
           "vuid": "VUID-VkBlitImageInfo2KHR-sType-sType",
@@ -24400,6 +24440,26 @@
         }
       ]
     },
+    "vkCmdSetPrimitiveRestartEnableEXT": {
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdSetPrimitiveRestartEnableEXT-None-04866",
+          "text": " The <a href=\"#features-extendedDynamicState2\">extendedDynamicState2</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-vkCmdSetPrimitiveRestartEnableEXT-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdSetPrimitiveRestartEnableEXT-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetPrimitiveRestartEnableEXT-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        }
+      ]
+    },
     "vkCmdSetPrimitiveTopologyEXT": {
       "(VK_EXT_extended_dynamic_state)": [
         {
@@ -24638,7 +24698,7 @@
         },
         {
           "vuid": "VUID-vkCmdDraw-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point <strong class=\"purple\">must</strong> not write to any resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
         },
         {
           "vuid": "VUID-vkCmdDraw-commandBuffer-04617",
@@ -24733,6 +24793,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDraw-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDraw-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDraw-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDraw-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDraw-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDraw-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -24902,7 +24984,7 @@
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point <strong class=\"purple\">must</strong> not write to any resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
         },
         {
           "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-04617",
@@ -24997,6 +25079,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndexed-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexed-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexed-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexed-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexed-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDrawIndexed-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -25293,6 +25397,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndirect-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirect-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirect-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirect-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirect-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDrawIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -25617,6 +25743,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndirectCount-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectCount-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectCount-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectCount-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectCount-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDrawIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -25919,6 +26067,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -26247,6 +26417,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDrawIndexedIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -26537,6 +26729,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_EXT_transform_feedback)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -26865,6 +27079,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksNV-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDrawMeshTasksNV-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -27145,6 +27381,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -27453,6 +27711,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -28602,6 +28882,26 @@
         }
       ]
     },
+    "vkCmdSetRasterizerDiscardEnableEXT": {
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdSetRasterizerDiscardEnableEXT-None-04871",
+          "text": " The <a href=\"#features-extendedDynamicState2\">extendedDynamicState2</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRasterizerDiscardEnableEXT-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRasterizerDiscardEnableEXT-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetRasterizerDiscardEnableEXT-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        }
+      ]
+    },
     "VkPipelineRasterizationStateStreamCreateInfoEXT": {
       "(VK_EXT_transform_feedback)": [
         {
@@ -29270,6 +29570,26 @@
         }
       ]
     },
+    "vkCmdSetDepthBiasEnableEXT": {
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdSetDepthBiasEnableEXT-None-04872",
+          "text": " The <a href=\"#features-extendedDynamicState2\">extendedDynamicState2</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-vkCmdSetDepthBiasEnableEXT-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdSetDepthBiasEnableEXT-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetDepthBiasEnableEXT-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        }
+      ]
+    },
     "VkPipelineRasterizationConservativeStateCreateInfoEXT": {
       "(VK_EXT_conservative_rasterization)": [
         {
@@ -30040,6 +30360,30 @@
         }
       ]
     },
+    "vkCmdSetLogicOpEXT": {
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdSetLogicOpEXT-None-04867",
+          "text": " The <a href=\"#features-extendedDynamicState2LogicOp\">extendedDynamicState2LogicOp</a> feature <strong class=\"purple\">must</strong> be enabled"
+        },
+        {
+          "vuid": "VUID-vkCmdSetLogicOpEXT-commandBuffer-parameter",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkCommandBuffer\">VkCommandBuffer</a> handle"
+        },
+        {
+          "vuid": "VUID-vkCmdSetLogicOpEXT-logicOp-parameter",
+          "text": " <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdSetLogicOpEXT-commandBuffer-recording",
+          "text": " <code>commandBuffer</code> <strong class=\"purple\">must</strong> be in the <a href=\"#commandbuffers-lifecycle\">recording state</a>"
+        },
+        {
+          "vuid": "VUID-vkCmdSetLogicOpEXT-commandBuffer-cmdpool",
+          "text": " The <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from <strong class=\"purple\">must</strong> support graphics operations"
+        }
+      ]
+    },
     "VkPipelineColorWriteCreateInfoEXT": {
       "(VK_EXT_color_write_enable)": [
         {
@@ -30226,7 +30570,7 @@
         },
         {
           "vuid": "VUID-vkCmdDispatch-commandBuffer-02713",
-          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point <strong class=\"purple\">must</strong> not write to any resource"
+          "text": " If <code>commandBuffer</code> is a protected command buffer, pipeline stages other than the framebuffer-space and compute stages in the <code>VkPipeline</code> object bound to the pipeline bind point used by this command <strong class=\"purple\">must</strong> not write to any resource"
         },
         {
           "vuid": "VUID-vkCmdDispatch-commandBuffer-04617",
@@ -30520,7 +30864,7 @@
         },
         {
           "vuid": "VUID-vkCmdDispatchBase-baseGroupX-00422",
-          "text": " <code>baseGroupX</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxComputeWorkGroupCount</code>[1]"
+          "text": " <code>baseGroupY</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxComputeWorkGroupCount</code>[1]"
         },
         {
           "vuid": "VUID-vkCmdDispatchBase-baseGroupZ-00423",
@@ -30691,10 +31035,6 @@
           "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkIndirectCommandsLayoutUsageFlagBitsNV\">VkIndirectCommandsLayoutUsageFlagBitsNV</a> values"
         },
         {
-          "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-flags-requiredbitmask",
-          "text": " <code>flags</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
-        },
-        {
           "vuid": "VUID-VkIndirectCommandsLayoutCreateInfoNV-pipelineBindPoint-parameter",
           "text": " <code>pipelineBindPoint</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkPipelineBindPoint\">VkPipelineBindPoint</a> value"
         },
@@ -31209,6 +31549,28 @@
           "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT</code> dynamic state enabled and an instance of <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a> chained from <code>VkPipelineVieportCreateInfo</code>, then the bound graphics pipeline <strong class=\"purple\">must</strong> have been created with <a href=\"#VkPipelineViewportExclusiveScissorStateCreateInfoNV\">VkPipelineViewportExclusiveScissorStateCreateInfoNV</a>::<code>exclusiveScissorCount</code> greater or equal to the <code>viewportCount</code> parameter in the last call to <a href=\"#vkCmdSetViewportWithCountEXT\">vkCmdSetViewportWithCountEXT</a>"
         }
       ],
+      "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04875",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPatchControlPointsEXT\">vkCmdSetPatchControlPointsEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04876",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetRasterizerDiscardEnableEXT\">vkCmdSetRasterizerDiscardEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04877",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetDepthBiasEnableEXT\">vkCmdSetDepthBiasEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        },
+        {
+          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-logicOp-04878",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_LOGIC_OP_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetLogicOpEXT\">vkCmdSetLogicOpEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command and the <code>logicOp</code> <strong class=\"purple\">must</strong> be a valid <a href=\"#VkLogicOp\">VkLogicOp</a> value"
+        },
+        {
+          "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04879",
+          "text": " If the bound graphics pipeline state was created with the <code>VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT</code> dynamic state enabled then <a href=\"#vkCmdSetPrimitiveRestartEnableEXT\">vkCmdSetPrimitiveRestartEnableEXT</a> <strong class=\"purple\">must</strong> have been called in the current command buffer prior to this draw command"
+        }
+      ],
       "(VK_NV_device_generated_commands)+(VK_KHR_fragment_shading_rate+VK_EXT_extended_dynamic_state)": [
         {
           "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-primitiveFragmentShadingRateWithMultipleViewports-04552",
@@ -31764,7 +32126,7 @@
         },
         {
           "vuid": "VUID-vkQueueBindSparse-pWaitSemaphores-01117",
-          "text": " All elements of the <code>pWaitSemaphores</code> member of all elements of <code>pBindInfo</code> member referring to a binary semaphore <strong class=\"purple\">must</strong> be semaphores that are signaled, or have <a href=\"#synchronization-semaphores-signaling\">semaphore signal operations</a> previously submitted for execution"
+          "text": " All elements of the <code>pWaitSemaphores</code> member of all elements of the <code>pBindInfo</code> parameter referring to a binary semaphore <strong class=\"purple\">must</strong> be semaphores that are signaled, or have <a href=\"#synchronization-semaphores-signaling\">semaphore signal operations</a> previously submitted for execution"
         },
         {
           "vuid": "VUID-vkQueueBindSparse-queue-parameter",
@@ -34228,7 +34590,7 @@
         },
         {
           "vuid": "VUID-VkDisplayPresentInfoKHR-persistentContent-01259",
-          "text": " If the <code>persistentContent</code> member of the <code>VkDisplayPropertiesKHR</code> structure returned by <code>vkGetPhysicalDeviceDisplayPropertiesKHR</code> for the display the present operation targets then <code>persistent</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
+          "text": " If the <code>persistentContent</code> member of the <code>VkDisplayPropertiesKHR</code> structure returned by <code>vkGetPhysicalDeviceDisplayPropertiesKHR</code> for the display the present operation targets is <code>VK_FALSE</code>, then <code>persistent</code> <strong class=\"purple\">must</strong> be <code>VK_FALSE</code>"
         },
         {
           "vuid": "VUID-VkDisplayPresentInfoKHR-sType-sType",
@@ -36474,7 +36836,7 @@
         },
         {
           "vuid": "VUID-vkCmdTraceRaysNV-None-03429",
-          "text": " Any shader group handle referenced by this call <strong class=\"purple\">must</strong> have been queried from the currently bound ray tracing shader pipeline"
+          "text": " Any shader group handle referenced by this call <strong class=\"purple\">must</strong> have been queried from the currently bound ray tracing pipeline"
         },
         {
           "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-04624",
@@ -36734,7 +37096,7 @@
         },
         {
           "vuid": "VUID-vkCmdTraceRaysKHR-None-03429",
-          "text": " Any shader group handle referenced by this call <strong class=\"purple\">must</strong> have been queried from the currently bound ray tracing shader pipeline"
+          "text": " Any shader group handle referenced by this call <strong class=\"purple\">must</strong> have been queried from the currently bound ray tracing pipeline"
         },
         {
           "vuid": "VUID-vkCmdTraceRaysKHR-maxPipelineRayRecursionDepth-03679",
@@ -37042,7 +37404,7 @@
         },
         {
           "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-03429",
-          "text": " Any shader group handle referenced by this call <strong class=\"purple\">must</strong> have been queried from the currently bound ray tracing shader pipeline"
+          "text": " Any shader group handle referenced by this call <strong class=\"purple\">must</strong> have been queried from the currently bound ray tracing pipeline"
         },
         {
           "vuid": "VUID-vkCmdTraceRaysIndirectKHR-maxPipelineRayRecursionDepth-03679",
@@ -39226,6 +39588,14 @@
         }
       ]
     },
+    "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT": {
+      "(VK_EXT_extended_dynamic_state2)": [
+        {
+          "vuid": "VUID-VkPhysicalDeviceExtendedDynamicState2FeaturesEXT-sType-sType",
+          "text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT</code>"
+        }
+      ]
+    },
     "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV": {
       "(VK_NV_device_generated_commands)": [
         {
diff --git a/registry/vk.xml b/registry/vk.xml
index 1f8a2df..a1c3194 100644
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -153,7 +153,7 @@ branch of the member gitlab server.
         <type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.2 version number
 #define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 175</type>
+#define <name>VK_HEADER_VERSION</name> 176</type>
         <type category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, VK_HEADER_VERSION)</type>
 
@@ -171,7 +171,7 @@ branch of the member gitlab server.
         <type category="define" requires="VK_USE_64_BIT_PTR_DEFINES" name="VK_NULL_HANDLE">
 #ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
     #if (VK_USE_64_BIT_PTR_DEFINES==1)
-        #if __cplusplus >= 201103L
+        #if __cplusplus >= 201103L || (defined(_MSVC_LANG) &amp;&amp; (_MSVC_LANG >= 201103L))
             #define VK_NULL_HANDLE nullptr
         #else
             #define VK_NULL_HANDLE ((void*)0)
@@ -2115,7 +2115,7 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkIndirectCommandsLayoutCreateInfoNV">
             <member values="VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true">const <type>void</type>*                             <name>pNext</name></member>
-            <member><type>VkIndirectCommandsLayoutUsageFlagsNV</type>    <name>flags</name></member>
+            <member optional="true"><type>VkIndirectCommandsLayoutUsageFlagsNV</type>    <name>flags</name></member>
             <member><type>VkPipelineBindPoint</type>                     <name>pipelineBindPoint</name></member>
             <member><type>uint32_t</type>                                <name>tokenCount</name></member>
             <member len="tokenCount">const <type>VkIndirectCommandsLayoutTokenNV</type>*  <name>pTokens</name></member>
@@ -4310,7 +4310,7 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkFramebufferAttachmentImageInfoKHR"                     alias="VkFramebufferAttachmentImageInfo"/>
         <type category="struct" name="VkRenderPassAttachmentBeginInfo" structextends="VkRenderPassBeginInfo">
             <member values="VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member>
-            <member optional="true">const <type>void</type>*                              <name>pNext</name></member>             <!-- Pointer to next structure -->
+            <member optional="true">const <type>void</type>*                              <name>pNext</name></member>
             <member optional="true"><type>uint32_t</type>                 <name>attachmentCount</name></member>
             <member len="attachmentCount">const <type>VkImageView</type>* <name>pAttachments</name></member>
         </type>
@@ -4405,7 +4405,7 @@ typedef void <name>CAMetalLayer</name>;
         </type>
         <type category="struct" name="VkPerformanceCounterKHR" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"><type>VkStructureType</type> <name>sType</name></member>
-            <member optional="true">const <type>void</type>*                             <name>pNext</name></member> <!-- Pointer to next structure -->
+            <member optional="true">const <type>void</type>*                             <name>pNext</name></member>
             <member><type>VkPerformanceCounterUnitKHR</type>        <name>unit</name></member>
             <member><type>VkPerformanceCounterScopeKHR</type>       <name>scope</name></member>
             <member><type>VkPerformanceCounterStorageKHR</type>     <name>storage</name></member>
@@ -4413,7 +4413,7 @@ typedef void <name>CAMetalLayer</name>;
         </type>
         <type category="struct" name="VkPerformanceCounterDescriptionKHR" returnedonly="true">
             <member values="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR"><type>VkStructureType</type> <name>sType</name></member>
-            <member optional="true">const <type>void</type>*                             <name>pNext</name></member> <!-- Pointer to next structure -->
+            <member optional="true">const <type>void</type>*                             <name>pNext</name></member>
             <member optional="true"><type>VkPerformanceCounterDescriptionFlagsKHR</type> <name>flags</name></member>
             <member><type>char</type>                                    <name>name</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
             <member><type>char</type>                                    <name>category</name>[<enum>VK_MAX_DESCRIPTION_SIZE</enum>]</member>
@@ -4421,7 +4421,7 @@ typedef void <name>CAMetalLayer</name>;
         </type>
         <type category="struct" name="VkQueryPoolPerformanceCreateInfoKHR" structextends="VkQueryPoolCreateInfo">
             <member values="VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
-            <member optional="true">const <type>void</type>*                             <name>pNext</name></member> <!-- Pointer to next structure -->
+            <member optional="true">const <type>void</type>*                             <name>pNext</name></member>
             <member><type>uint32_t</type>                                <name>queueFamilyIndex</name></member>
             <member><type>uint32_t</type>                                <name>counterIndexCount</name></member>
             <member len="counterIndexCount">const <type>uint32_t</type>* <name>pCounterIndices</name></member>
@@ -5011,6 +5011,13 @@ typedef void <name>CAMetalLayer</name>;
             <member optional="true"><type>void</type>*        <name>pNext</name></member>
             <member><type>VkBool32</type>                           <name>extendedDynamicState</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceExtendedDynamicState2FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true"><type>void</type>*        <name>pNext</name></member>
+            <member><type>VkBool32</type>                     <name>extendedDynamicState2</name></member>
+            <member><type>VkBool32</type>                     <name>extendedDynamicState2LogicOp</name></member>
+            <member><type>VkBool32</type>                     <name>extendedDynamicState2PatchControlPoints</name></member>
+        </type>
         <type category="struct" name="VkRenderPassTransformBeginInfoQCOM" structextends="VkRenderPassBeginInfo">
             <member values="VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true"><type>void</type>*                           <name>pNext</name><comment>Pointer to next structure</comment></member>
@@ -5763,21 +5770,21 @@ typedef void <name>CAMetalLayer</name>;
           <member><type>uint8_t</type>                                         <name>maxQp</name></member>
         </type>
         <type category="struct" name="VkPhysicalDeviceInheritedViewportScissorFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
-             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
-             <member><type>void</type>*                               <name>pNext</name></member>
-             <member><type>VkBool32</type>                            <name>inheritedViewportScissor2D</name></member>
+          <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+          <member><type>void</type>*                               <name>pNext</name></member>
+          <member><type>VkBool32</type>                            <name>inheritedViewportScissor2D</name></member>
         </type>
         <type category="struct" name="VkCommandBufferInheritanceViewportScissorInfoNV" structextends="VkCommandBufferInheritanceInfo">
-            <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
-            <member>const <type>void</type>*                                    <name>pNext</name></member>
-            <member><type>VkBool32</type>                                       <name>viewportScissor2D</name></member>
-            <member><type>uint32_t</type>                                       <name>viewportDepthCount</name></member>
-            <member noautovalidity="true">const <type>VkViewport</type>*        <name>pViewportDepths</name></member>
+          <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
+          <member>const <type>void</type>*                                    <name>pNext</name></member>
+          <member><type>VkBool32</type>                                       <name>viewportScissor2D</name></member>
+          <member><type>uint32_t</type>                                       <name>viewportDepthCount</name></member>
+          <member noautovalidity="true">const <type>VkViewport</type>*        <name>pViewportDepths</name></member>
         </type>
         <type category="struct" name="VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
-            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
-            <member optional="true"><type>void</type>*        <name>pNext</name></member>
-            <member><type>VkBool32</type>                     <name>ycbcr2plane444Formats</name></member>
+          <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+          <member optional="true"><type>void</type>*        <name>pNext</name></member>
+          <member><type>VkBool32</type>                     <name>ycbcr2plane444Formats</name></member>
         </type>
     </types>
     <comment>Vulkan enumerant (token) definitions</comment>
@@ -10036,6 +10043,31 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>VkStencilOp</type> <name>depthFailOp</name></param>
             <param><type>VkCompareOp</type> <name>compareOp</name></param>
         </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetPatchControlPointsEXT</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>uint32_t</type> <name>patchControlPoints</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetRasterizerDiscardEnableEXT</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkBool32</type> <name>rasterizerDiscardEnable</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetDepthBiasEnableEXT</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkBool32</type> <name>depthBiasEnable</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetLogicOpEXT</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkLogicOp</type> <name>logicOp</name></param>
+        </command>
+        <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary">
+            <proto><type>void</type> <name>vkCmdSetPrimitiveRestartEnableEXT</name></proto>
+            <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
+            <param><type>VkBool32</type> <name>primitiveRestartEnable</name></param>
+        </command>
         <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY">
             <proto><type>VkResult</type> <name>vkCreatePrivateDataSlotEXT</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
@@ -10377,7 +10409,6 @@ typedef void <name>CAMetalLayer</name>;
             <type name="VkQueueFlags"/>
             <type name="VkSampleCountFlagBits"/>
             <type name="VkSampleCountFlags"/>
-            <type name="VkStructureType"/>
             <type name="VkSystemAllocationScope"/>
             <command name="vkCreateInstance"/>
             <command name="vkDestroyInstance"/>
@@ -11232,7 +11263,6 @@ typedef void <name>CAMetalLayer</name>;
             <enum offset="0" extends="VkStructureType" extnumber="212"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"/>
             <type name="VkPhysicalDeviceVulkanMemoryModelFeatures"/>
         </require>
-            <!-- Phase 2 features -->
         <require comment="Promoted from VK_KHR_imageless_framebuffer (extension 109)">
             <type name="VkPhysicalDeviceImagelessFramebufferFeatures"/>
             <type name="VkFramebufferAttachmentsCreateInfo"/>
@@ -11507,7 +11537,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_debug_report" number="12" type="instance" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" specialuse="debugging" supported="vulkan" deprecatedby="VK_EXT_debug_utils">
             <require>
-                <enum value="9"                                                 name="VK_EXT_DEBUG_REPORT_SPEC_VERSION"/>
+                <enum value="10"                                                name="VK_EXT_DEBUG_REPORT_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_debug_report&quot;"                   name="VK_EXT_DEBUG_REPORT_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"/>
                 <enum alias="VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT" comment="Backwards-compatible alias containing a typo"/>
@@ -11725,7 +11755,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_video_encode_queue" number="300"  type="device" requires="VK_KHR_video_queue,VK_KHR_synchronization2" author="KHR" contact="[email protected]" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="1"                                         name="VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION"/>
+                <enum value="2"                                         name="VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_video_encode_queue&quot;"     name="VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME"/>
                 <enum bitpos="27" extends="VkPipelineStageFlagBits2KHR" name="VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS" />
                 <enum bitpos="37" extends="VkAccessFlagBits2KHR"        name="VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS" />
@@ -13947,7 +13977,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_calibrated_timestamps" number="185" type="device" author="EXT" contact="Daniel Rakos @drakos-amd" supported="vulkan">
             <require>
-                <enum value="1"                                             name="VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION"/>
+                <enum value="2"                                             name="VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_calibrated_timestamps&quot;"      name="VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"/>
                 <type name="VkTimeDomainEXT"/>
@@ -15466,10 +15496,10 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_zero_initialize_workgroup_memory" number="326" type="device" requires="VK_KHR_get_physical_device_properties2" author="KHR" contact="Alan Baker @alan-baker" supported="vulkan">
             <require>
-              <enum value="1" name="VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION"/>
-              <enum value="&quot;VK_KHR_zero_initialize_workgroup_memory&quot;" name="VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME"/>
-              <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR"/>
-              <type name="VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR"/>
+                <enum value="1" name="VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_zero_initialize_workgroup_memory&quot;" name="VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR"/>
+                <type name="VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR"/>
             </require>
         </extension>
         <extension name="VK_NV_fragment_shading_rate_enums" number="327" type="device" requires="VK_KHR_fragment_shading_rate" author="NV" contact="Pat Brown @nvpbrown" supported="vulkan">
@@ -15539,7 +15569,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_QCOM_rotated_copy_commands" number="334" type="device" requires="VK_KHR_swapchain,VK_KHR_copy_commands2" author="QCOM" contact="Jeff Leger @jackohound" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION"/>
+                <enum value="1"                                             name="VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION"/>
                 <enum value="&quot;VK_QCOM_rotated_copy_commands&quot;"     name="VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM"/>
                 <type name="VkCopyCommandTransformInfoQCOM"/>
@@ -15774,32 +15804,32 @@ typedef void <name>CAMetalLayer</name>;
             </require>
         </extension>
         <extension name="VK_FUCHSIA_external_memory" number="365" type="device" requires="VK_KHR_external_memory_capabilities,VK_KHR_external_memory" author="FUCHSIA" contact="John Rosasco @rosasco" platform="fuchsia" supported="vulkan">
-          <require>
-            <enum value="1"                                                name="VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION"/>
-            <enum value="&quot;VK_FUCHSIA_external_memory&quot;"           name="VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME"/>
-            <enum offset="0" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"/>
-            <enum offset="1" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"/>
-            <enum offset="2" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"/>
-            <enum bitpos="11" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA"/>
-            <type name="VkImportMemoryZirconHandleInfoFUCHSIA"/>
-            <type name="VkMemoryZirconHandlePropertiesFUCHSIA"/>
-            <type name="VkMemoryGetZirconHandleInfoFUCHSIA"/>
-            <command name="vkGetMemoryZirconHandleFUCHSIA"/>
-            <command name="vkGetMemoryZirconHandlePropertiesFUCHSIA"/>
-          </require>
+            <require>
+                <enum value="1"                                                name="VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION"/>
+                <enum value="&quot;VK_FUCHSIA_external_memory&quot;"           name="VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"/>
+                <enum offset="1" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"/>
+                <enum offset="2" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"/>
+                <enum bitpos="11" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA"/>
+                <type name="VkImportMemoryZirconHandleInfoFUCHSIA"/>
+                <type name="VkMemoryZirconHandlePropertiesFUCHSIA"/>
+                <type name="VkMemoryGetZirconHandleInfoFUCHSIA"/>
+                <command name="vkGetMemoryZirconHandleFUCHSIA"/>
+                <command name="vkGetMemoryZirconHandlePropertiesFUCHSIA"/>
+            </require>
         </extension>
         <extension name="VK_FUCHSIA_external_semaphore" number="366" type="device" requires="VK_KHR_external_semaphore_capabilities,VK_KHR_external_semaphore" author="FUCHSIA" contact="John Rosasco @rosasco" platform="fuchsia" supported="vulkan">
-          <require>
-            <enum value="1"                                                name="VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION"/>
-            <enum value="&quot;VK_FUCHSIA_external_semaphore&quot;"        name="VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME"/>
-            <enum offset="0" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"/>
-            <enum offset="1" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"/>
-            <enum bitpos="7" extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA"/>
-            <type name="VkImportSemaphoreZirconHandleInfoFUCHSIA"/>
-            <type name="VkSemaphoreGetZirconHandleInfoFUCHSIA"/>
-            <command name="vkImportSemaphoreZirconHandleFUCHSIA"/>
-            <command name="vkGetSemaphoreZirconHandleFUCHSIA"/>
-          </require>
+            <require>
+                <enum value="1"                                                name="VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION"/>
+                <enum value="&quot;VK_FUCHSIA_external_semaphore&quot;"        name="VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"/>
+                <enum offset="1" extends="VkStructureType"                     name="VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"/>
+                <enum bitpos="7" extends="VkExternalSemaphoreHandleTypeFlagBits" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA"/>
+                <type name="VkImportSemaphoreZirconHandleInfoFUCHSIA"/>
+                <type name="VkSemaphoreGetZirconHandleInfoFUCHSIA"/>
+                <command name="vkImportSemaphoreZirconHandleFUCHSIA"/>
+                <command name="vkGetSemaphoreZirconHandleFUCHSIA"/>
+            </require>
         </extension>
         <extension name="VK_FUCHSIA_extension_367" number="367" author="FUCHSIA" contact="Craig Stout @cdotstout" supported="disabled">
             <require>
@@ -15874,12 +15904,24 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_EXT_extension_377&quot;"          name="VK_EXT_EXTENSION_377_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_378" number="378" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="disabled">
-            <require>
-                <enum value="0"                                         name="VK_NV_EXTENSION_378_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_378&quot;"           name="VK_NV_EXTENSION_378_EXTENSION_NAME"/>
-            </require>
-        </extension>
+        <extension name="VK_EXT_extended_dynamic_state2" number="378" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
+            <require>
+                <enum value="1"                                             name="VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extended_dynamic_state2&quot;"     name="VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"/>
+                <enum offset="0" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT"/>
+                <enum offset="1" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT"/>
+                <enum offset="2" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT"/>
+                <enum offset="3" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_LOGIC_OP_EXT"/>
+                <enum offset="4" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT"/>
+                <type name="VkPhysicalDeviceExtendedDynamicState2FeaturesEXT"/>
+                <command name="vkCmdSetPatchControlPointsEXT"/>
+                <command name="vkCmdSetRasterizerDiscardEnableEXT"/>
+                <command name="vkCmdSetDepthBiasEnableEXT"/>
+                <command name="vkCmdSetLogicOpEXT"/>
+                <command name="vkCmdSetPrimitiveRestartEnableEXT"/>
+             </require>
+         </extension>
         <extension name="VK_QNX_screen_surface" number="379" type="instance" requires="VK_KHR_surface" platform="screen" author="QNX" contact="Mike Gorchak @mgorchak-blackberry" supported="vulkan">
             <require>
                 <enum value="1"                                         name="VK_QNX_SCREEN_SURFACE_SPEC_VERSION"/>
@@ -15946,10 +15988,10 @@ typedef void <name>CAMetalLayer</name>;
             </require>
           </extension>
         <extension name="VK_EXT_extension_388" number="388" author="EXT" contact="Alan Baker @alan-baker" supported="disabled">
-          <require>
-              <enum value="0"                                             name="VK_EXT_EXTENSION_388_SPEC_VERSION"/>
-              <enum value="&quot;VK_EXT_extension_388&quot;"              name="VK_EXT_EXTENSION_388_EXTENSION_NAME"/>
-          </require>
+            <require>
+                <enum value="0"                                             name="VK_EXT_EXTENSION_388_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_388&quot;"              name="VK_EXT_EXTENSION_388_EXTENSION_NAME"/>
+            </require>
         </extension>
         <extension name="VK_EXT_extension_389" number="389" author="EXT" contact="Yiwei Zhang @zhangyiwei" supported="disabled">
             <require>
@@ -15987,6 +16029,12 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_EXT_extension_394&quot;"              name="VK_EXT_EXTENSION_394_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_KHR_extension_395" number="395" author="KHR" contact="Lenny Komow @lkomow" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_KHR_EXTENSION_395_SPEC_VERSION"/>
+                <enum value="&quot;VK_KHR_extension_395&quot;"              name="VK_KHR_EXTENSION_395_EXTENSION_NAME"/>
+            </require>
+        </extension>
     </extensions>
     <spirvextensions comment="SPIR-V Extensions allowed in Vulkan and what is required to use it">
         <spirvextension name="SPV_KHR_variable_pointers">
diff --git a/registry/vkconventions.py b/registry/vkconventions.py
index 5ceeeb0..a77beb6 100644
--- a/registry/vkconventions.py
+++ b/registry/vkconventions.py
@@ -87,6 +87,7 @@ class VulkanConventions(ConventionsBase):
 
     def generate_structure_type_from_name(self, structname):
         """Generate a structure type name, like VK_STRUCTURE_TYPE_CREATE_INSTANCE_INFO"""
+
         structure_type_parts = []
         # Tokenize into "words"
         for elem in MAIN_RE.findall(structname):
@@ -95,7 +96,18 @@ class VulkanConventions(ConventionsBase):
                 structure_type_parts.append('VK_STRUCTURE_TYPE')
             else:
                 structure_type_parts.append(word.upper())
-        return '_'.join(structure_type_parts)
+        name = '_'.join(structure_type_parts)
+
+        # The simple-minded rules need modification for some structure names
+        subpats = [
+            [ r'_H_(26[45])_',              r'_H\1_' ],
+            [ r'_VULKAN_([0-9])([0-9])_',   r'_VULKAN_\1_\2_' ],
+            [ r'_DIRECT_FB_',               r'_DIRECTFB_' ],
+        ]
+
+        for subpat in subpats:
+            name = re.sub(subpat[0], subpat[1], name)
+        return name
 
     @property
     def warning_comment(self):