Merge pull request #645 from asuessenbach/145

Update and adjustments to VK_HEADER_VERSION 145.

Vulkan-Headers

@@ -1 +1 @@
-Subproject commit f31524575668c6c483356bd54ca974590e31be8e
+Subproject commit 8188e3fbbc105591064093440f88081fb957d4f0

VulkanHppGenerator.cpp

@@ -5518,10 +5518,11 @@ void VulkanHppGenerator::readExtensionDisabledEnum( std::string const &
 {
   int                                line       = element->GetLineNum();
   std::map<std::string, std::string> attributes = getAttributes( element );
-  checkAttributes( line,
+  checkAttributes(
+    line,
     attributes,
     { { "name", {} } },
-                   { { "alias", {} }, { "bitpos", {} }, { "extends", {} }, { "offset", {} }, { "value", {} } } );
+    { { "alias", {} }, { "bitpos", {} }, { "extends", {} }, { "extnumber", {} }, { "offset", {} }, { "value", {} } } );
   checkElements( line, getChildElements( element ), {} );
 
   std::string extends, name;

vulkan/vulkan.hpp

@@ -74,7 +74,7 @@ static_assert( false, "vulkan.hpp needs at least c++ standard version 11" );
 #  include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION == 144, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 145, "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
@@ -1204,6 +1204,18 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
     }
 
+    void vkCmdBindVertexBuffers2EXT( VkCommandBuffer      commandBuffer,
+                                     uint32_t             firstBinding,
+                                     uint32_t             bindingCount,
+                                     const VkBuffer *     pBuffers,
+                                     const VkDeviceSize * pOffsets,
+                                     const VkDeviceSize * pSizes,
+                                     const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdBindVertexBuffers2EXT(
+        commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
+    }
+
     void vkCmdBlitImage( VkCommandBuffer     commandBuffer,
                          VkImage             srcImage,
                          VkImageLayout       srcImageLayout,
@@ -1783,6 +1795,11 @@ namespace VULKAN_HPP_NAMESPACE
         commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
     }
 
+    void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
+    }
+
     void vkCmdSetDepthBias( VkCommandBuffer commandBuffer,
                             float           depthBiasConstantFactor,
                             float           depthBiasClamp,
@@ -1798,6 +1815,29 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
     }
 
+    void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer,
+                                           VkBool32        depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
+    }
+
+    void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer,
+                                    VkCompareOp     depthCompareOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
+    }
+
+    void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
+    }
+
+    void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer,
+                                      VkBool32        depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
+    }
+
     void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
     {
       return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
@@ -1833,6 +1873,11 @@ namespace VULKAN_HPP_NAMESPACE
         commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
     }
 
+    void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
+    }
+
     void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer,
                                  uint32_t        lineStippleFactor,
                                  uint16_t        lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
@@ -1865,6 +1910,12 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
     }
 
+    void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer     commandBuffer,
+                                       VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
+    }
+
     void vkCmdSetSampleLocationsEXT( VkCommandBuffer                  commandBuffer,
                                      const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
     {
@@ -1879,6 +1930,13 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
     }
 
+    void vkCmdSetScissorWithCountEXT( VkCommandBuffer  commandBuffer,
+                                      uint32_t         scissorCount,
+                                      const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
+    }
+
     void vkCmdSetStencilCompareMask( VkCommandBuffer    commandBuffer,
                                      VkStencilFaceFlags faceMask,
                                      uint32_t           compareMask ) const VULKAN_HPP_NOEXCEPT
@@ -1886,6 +1944,16 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
     }
 
+    void vkCmdSetStencilOpEXT( VkCommandBuffer    commandBuffer,
+                               VkStencilFaceFlags faceMask,
+                               VkStencilOp        failOp,
+                               VkStencilOp        passOp,
+                               VkStencilOp        depthFailOp,
+                               VkCompareOp        compareOp ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
+    }
+
     void vkCmdSetStencilReference( VkCommandBuffer    commandBuffer,
                                    VkStencilFaceFlags faceMask,
                                    uint32_t           reference ) const VULKAN_HPP_NOEXCEPT
@@ -1893,6 +1961,12 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
     }
 
+    void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer,
+                                       VkBool32        stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
+    }
+
     void vkCmdSetStencilWriteMask( VkCommandBuffer    commandBuffer,
                                    VkStencilFaceFlags faceMask,
                                    uint32_t           writeMask ) const VULKAN_HPP_NOEXCEPT
@@ -1926,6 +2000,13 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
     }
 
+    void vkCmdSetViewportWithCountEXT( VkCommandBuffer    commandBuffer,
+                                       uint32_t           viewportCount,
+                                       const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
+    }
+
 #  ifdef VK_ENABLE_BETA_EXTENSIONS
     void vkCmdTraceRaysIndirectKHR( VkCommandBuffer                  commandBuffer,
                                     const VkStridedBufferRegionKHR * pRaygenShaderBindingTable,
@@ -6052,7 +6133,19 @@ namespace VULKAN_HPP_NAMESPACE
     eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV,
     eViewportCoarseSampleOrderNV  = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV,
     eExclusiveScissorNV           = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV,
-    eLineStippleEXT               = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT
+    eLineStippleEXT               = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT,
+    eCullModeEXT                  = VK_DYNAMIC_STATE_CULL_MODE_EXT,
+    eFrontFaceEXT                 = VK_DYNAMIC_STATE_FRONT_FACE_EXT,
+    ePrimitiveTopologyEXT         = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT,
+    eViewportWithCountEXT         = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT,
+    eScissorWithCountEXT          = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT,
+    eVertexInputBindingStrideEXT  = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT,
+    eDepthTestEnableEXT           = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT,
+    eDepthWriteEnableEXT          = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT,
+    eDepthCompareOpEXT            = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT,
+    eDepthBoundsTestEnableEXT     = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT,
+    eStencilTestEnableEXT         = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
+    eStencilOpEXT                 = VK_DYNAMIC_STATE_STENCIL_OP_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( DynamicState value )
@@ -6075,6 +6168,18 @@ namespace VULKAN_HPP_NAMESPACE
       case DynamicState::eViewportCoarseSampleOrderNV: return "ViewportCoarseSampleOrderNV";
       case DynamicState::eExclusiveScissorNV: return "ExclusiveScissorNV";
       case DynamicState::eLineStippleEXT: return "LineStippleEXT";
+      case DynamicState::eCullModeEXT: return "CullModeEXT";
+      case DynamicState::eFrontFaceEXT: return "FrontFaceEXT";
+      case DynamicState::ePrimitiveTopologyEXT: return "PrimitiveTopologyEXT";
+      case DynamicState::eViewportWithCountEXT: return "ViewportWithCountEXT";
+      case DynamicState::eScissorWithCountEXT: return "ScissorWithCountEXT";
+      case DynamicState::eVertexInputBindingStrideEXT: return "VertexInputBindingStrideEXT";
+      case DynamicState::eDepthTestEnableEXT: return "DepthTestEnableEXT";
+      case DynamicState::eDepthWriteEnableEXT: return "DepthWriteEnableEXT";
+      case DynamicState::eDepthCompareOpEXT: return "DepthCompareOpEXT";
+      case DynamicState::eDepthBoundsTestEnableEXT: return "DepthBoundsTestEnableEXT";
+      case DynamicState::eStencilTestEnableEXT: return "StencilTestEnableEXT";
+      case DynamicState::eStencilOpEXT: return "StencilOpEXT";
       default: return "invalid";
     }
   }
@@ -9396,6 +9501,8 @@ namespace VULKAN_HPP_NAMESPACE
     ePipelineRasterizationLineStateCreateInfoEXT  = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
     ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
     ePhysicalDeviceIndexTypeUint8FeaturesEXT      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
+    ePhysicalDeviceExtendedDynamicStateFeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
     eDeferredOperationInfoKHR = VK_STRUCTURE_TYPE_DEFERRED_OPERATION_INFO_KHR,
     ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR =
       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
@@ -10069,6 +10176,8 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT:
         return "PhysicalDeviceLineRasterizationPropertiesEXT";
       case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT: return "PhysicalDeviceIndexTypeUint8FeaturesEXT";
+      case StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT:
+        return "PhysicalDeviceExtendedDynamicStateFeaturesEXT";
       case StructureType::eDeferredOperationInfoKHR: return "DeferredOperationInfoKHR";
       case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR:
         return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
@@ -16552,6 +16661,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceDriverProperties;
   using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
   struct PhysicalDeviceExclusiveScissorFeaturesNV;
+  struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
   struct PhysicalDeviceExternalBufferInfo;
   using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
   struct PhysicalDeviceExternalFenceInfo;
@@ -18594,6 +18704,24 @@ namespace VULKAN_HPP_NAMESPACE
                             Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void bindVertexBuffers2EXT( uint32_t                                 firstBinding,
+                                uint32_t                                 bindingCount,
+                                const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
+                                const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
+                                const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
+                                const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
+                                Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void bindVertexBuffers2EXT( uint32_t                                           firstBinding,
+                                ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer>     buffers,
+                                ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> offsets,
+                                ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> sizes,
+                                ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> strides,
+                                Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
@@ -19232,6 +19360,10 @@ namespace VULKAN_HPP_NAMESPACE
                                  Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
+                         Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setDepthBias( float            depthBiasConstantFactor,
                        float            depthBiasClamp,
@@ -19243,6 +19375,22 @@ namespace VULKAN_HPP_NAMESPACE
                          float            maxDepthBounds,
                          Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
+                                      Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
+                               Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
+                                Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
+                                 Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setDeviceMask( uint32_t         deviceMask,
                         Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
@@ -19280,6 +19428,10 @@ namespace VULKAN_HPP_NAMESPACE
                                 Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
+                          Dispatch const &                d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setLineStippleEXT( uint32_t         lineStippleFactor,
                             uint16_t         lineStipplePattern,
@@ -19319,6 +19471,10 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
+                                  Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
                                 Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
@@ -19340,16 +19496,38 @@ namespace VULKAN_HPP_NAMESPACE
                      Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setScissorWithCountEXT( uint32_t                             scissorCount,
+                                 const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
+                                 Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> scissors,
+                                 Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
                                 uint32_t                               compareMask,
                                 Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                          VULKAN_HPP_NAMESPACE::StencilOp        failOp,
+                          VULKAN_HPP_NAMESPACE::StencilOp        passOp,
+                          VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
+                          VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
+                          Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
                               uint32_t                               reference,
                               Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
+                                  Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
                               uint32_t                               writeMask,
@@ -19393,6 +19571,16 @@ namespace VULKAN_HPP_NAMESPACE
                                 Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setViewportWithCountEXT( uint32_t                               viewportCount,
+                                  const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
+                                  Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> viewports,
+                                  Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedBufferRegionKHR * pRaygenShaderBindingTable,
@@ -57181,6 +57369,94 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceExclusiveScissorFeaturesNV;
   };
 
+  struct PhysicalDeviceExtendedDynamicStateFeaturesEXT
+  {
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT;
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicStateFeaturesEXT(
+      VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState_ = {} ) VULKAN_HPP_NOEXCEPT
+      : extendedDynamicState( extendedDynamicState_ )
+    {}
+
+    PhysicalDeviceExtendedDynamicStateFeaturesEXT &
+      operator=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext,
+              &rhs.pNext,
+              sizeof( PhysicalDeviceExtendedDynamicStateFeaturesEXT ) -
+                offsetof( PhysicalDeviceExtendedDynamicStateFeaturesEXT, pNext ) );
+      return *this;
+    }
+
+    PhysicalDeviceExtendedDynamicStateFeaturesEXT( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs )
+      VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+    PhysicalDeviceExtendedDynamicStateFeaturesEXT &
+      operator=( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const *>( &rhs );
+      return *this;
+    }
+
+    PhysicalDeviceExtendedDynamicStateFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceExtendedDynamicStateFeaturesEXT &
+      setExtendedDynamicState( VULKAN_HPP_NAMESPACE::Bool32 extendedDynamicState_ ) VULKAN_HPP_NOEXCEPT
+    {
+      extendedDynamicState = extendedDynamicState_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>( this );
+    }
+
+    operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState );
+    }
+
+    bool operator!=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT;
+    void *                                    pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32              extendedDynamicState = {};
+  };
+  static_assert( sizeof( PhysicalDeviceExtendedDynamicStateFeaturesEXT ) ==
+                   sizeof( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceExtendedDynamicStateFeaturesEXT>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT>
+  {
+    using Type = PhysicalDeviceExtendedDynamicStateFeaturesEXT;
+  };
+
   struct PhysicalDeviceExternalBufferInfo
   {
     static const bool                                  allowDuplicate = false;
@@ -80135,6 +80411,97 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t                                 firstBinding,
+                                                               uint32_t                                 bindingCount,
+                                                               const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
+                                                               const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
+                                                               const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
+                                                               const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdBindVertexBuffers2EXT( m_commandBuffer,
+                                  firstBinding,
+                                  bindingCount,
+                                  reinterpret_cast<const VkBuffer *>( pBuffers ),
+                                  reinterpret_cast<const VkDeviceSize *>( pOffsets ),
+                                  reinterpret_cast<const VkDeviceSize *>( pSizes ),
+                                  reinterpret_cast<const VkDeviceSize *>( pStrides ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::bindVertexBuffers2EXT( uint32_t                                           firstBinding,
+                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer>     buffers,
+                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> offsets,
+                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> sizes,
+                                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> strides,
+                                          Dispatch const &                                   d ) const
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
+#  else
+    if ( buffers.size() != offsets.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::VkCommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( buffers.size() == sizes.size() );
+#  else
+    if ( buffers.size() != sizes.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::VkCommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( buffers.size() == strides.size() );
+#  else
+    if ( buffers.size() != strides.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::VkCommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( offsets.size() == sizes.size() );
+#  else
+    if ( offsets.size() != sizes.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::VkCommandBuffer::bindVertexBuffers2EXT: offsets.size() != sizes.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( offsets.size() == strides.size() );
+#  else
+    if ( offsets.size() != strides.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::VkCommandBuffer::bindVertexBuffers2EXT: offsets.size() != strides.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    VULKAN_HPP_ASSERT( sizes.size() == strides.size() );
+#  else
+    if ( sizes.size() != strides.size() )
+    {
+      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
+                        "::VkCommandBuffer::bindVertexBuffers2EXT: sizes.size() != strides.size()" );
+    }
+#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+    d.vkCmdBindVertexBuffers2EXT( m_commandBuffer,
+                                  firstBinding,
+                                  buffers.size(),
+                                  reinterpret_cast<const VkBuffer *>( buffers.data() ),
+                                  reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
+                                  reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
+                                  reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
                                                    VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
@@ -81827,6 +82194,22 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetCullModeEXT( m_commandBuffer, static_cast<VkCullModeFlags>( cullMode ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
+                                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetCullModeEXT( m_commandBuffer, static_cast<VkCullModeFlags>( cullMode ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float            depthBiasConstantFactor,
@@ -81865,6 +82248,70 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
+                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthBoundsTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBoundsTestEnable ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
+                                                                     Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthBoundsTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthBoundsTestEnable ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthCompareOpEXT( m_commandBuffer, static_cast<VkCompareOp>( depthCompareOp ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
+                                                              Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthCompareOpEXT( m_commandBuffer, static_cast<VkCompareOp>( depthCompareOp ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthTestEnable ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
+                                                               Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthTestEnable ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
+                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthWriteEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthWriteEnable ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
+                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetDepthWriteEnableEXT( m_commandBuffer, static_cast<VkBool32>( depthWriteEnable ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t         deviceMask,
@@ -81965,6 +82412,22 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
+                                                         Dispatch const &                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetFrontFaceEXT( m_commandBuffer, static_cast<VkFrontFace>( frontFace ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetFrontFaceEXT( m_commandBuffer, static_cast<VkFrontFace>( frontFace ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t         lineStippleFactor,
@@ -82055,6 +82518,24 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
+                                            Dispatch const &                        d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetPrimitiveTopologyEXT( m_commandBuffer, static_cast<VkPrimitiveTopology>( primitiveTopology ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetPrimitiveTopologyEXT( m_commandBuffer, static_cast<VkPrimitiveTopology>( primitiveTopology ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
     CommandBuffer::setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
@@ -82092,6 +82573,23 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( uint32_t                             scissorCount,
+                                                                const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
+                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> scissors,
+                                                                Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetScissorWithCountEXT(
+      m_commandBuffer, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
@@ -82110,6 +82608,40 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                                         VULKAN_HPP_NAMESPACE::StencilOp        failOp,
+                                                         VULKAN_HPP_NAMESPACE::StencilOp        passOp,
+                                                         VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
+                                                         VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetStencilOpEXT( m_commandBuffer,
+                            static_cast<VkStencilFaceFlags>( faceMask ),
+                            static_cast<VkStencilOp>( failOp ),
+                            static_cast<VkStencilOp>( passOp ),
+                            static_cast<VkStencilOp>( depthFailOp ),
+                            static_cast<VkCompareOp>( compareOp ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
+                                                         VULKAN_HPP_NAMESPACE::StencilOp failOp,
+                                                         VULKAN_HPP_NAMESPACE::StencilOp passOp,
+                                                         VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
+                                                         VULKAN_HPP_NAMESPACE::CompareOp compareOp,
+                                                         Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetStencilOpEXT( m_commandBuffer,
+                            static_cast<VkStencilFaceFlags>( faceMask ),
+                            static_cast<VkStencilOp>( failOp ),
+                            static_cast<VkStencilOp>( passOp ),
+                            static_cast<VkStencilOp>( depthFailOp ),
+                            static_cast<VkCompareOp>( compareOp ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
@@ -82128,6 +82660,22 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
+                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetStencilTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( stencilTestEnable ) );
+  }
+#else
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
+                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetStencilTestEnableEXT( m_commandBuffer, static_cast<VkBool32>( stencilTestEnable ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
@@ -82219,6 +82767,25 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( uint32_t                               viewportCount,
+                                                                 const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
+                                                                 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewportWithCountEXT(
+      m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
+  }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void
+    CommandBuffer::setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> viewports,
+                                            Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    d.vkCmdSetViewportWithCountEXT(
+      m_commandBuffer, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
+  }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
 #ifdef VK_ENABLE_BETA_EXTENSIONS
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR(
@@ -95709,6 +96276,22 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>
   {
     enum
@@ -97410,6 +97993,7 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCmdBindShadingRateImageNV            vkCmdBindShadingRateImageNV            = 0;
     PFN_vkCmdBindTransformFeedbackBuffersEXT   vkCmdBindTransformFeedbackBuffersEXT   = 0;
     PFN_vkCmdBindVertexBuffers                 vkCmdBindVertexBuffers                 = 0;
+    PFN_vkCmdBindVertexBuffers2EXT             vkCmdBindVertexBuffers2EXT             = 0;
     PFN_vkCmdBlitImage                         vkCmdBlitImage                         = 0;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     PFN_vkCmdBuildAccelerationStructureIndirectKHR vkCmdBuildAccelerationStructureIndirectKHR = 0;
@@ -97483,26 +98067,37 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkCmdSetBlendConstants                vkCmdSetBlendConstants                = 0;
     PFN_vkCmdSetCheckpointNV                  vkCmdSetCheckpointNV                  = 0;
     PFN_vkCmdSetCoarseSampleOrderNV           vkCmdSetCoarseSampleOrderNV           = 0;
+    PFN_vkCmdSetCullModeEXT                   vkCmdSetCullModeEXT                   = 0;
     PFN_vkCmdSetDepthBias                     vkCmdSetDepthBias                     = 0;
     PFN_vkCmdSetDepthBounds                   vkCmdSetDepthBounds                   = 0;
+    PFN_vkCmdSetDepthBoundsTestEnableEXT      vkCmdSetDepthBoundsTestEnableEXT      = 0;
+    PFN_vkCmdSetDepthCompareOpEXT             vkCmdSetDepthCompareOpEXT             = 0;
+    PFN_vkCmdSetDepthTestEnableEXT            vkCmdSetDepthTestEnableEXT            = 0;
+    PFN_vkCmdSetDepthWriteEnableEXT           vkCmdSetDepthWriteEnableEXT           = 0;
     PFN_vkCmdSetDeviceMask                    vkCmdSetDeviceMask                    = 0;
     PFN_vkCmdSetDeviceMaskKHR                 vkCmdSetDeviceMaskKHR                 = 0;
     PFN_vkCmdSetDiscardRectangleEXT           vkCmdSetDiscardRectangleEXT           = 0;
     PFN_vkCmdSetEvent                         vkCmdSetEvent                         = 0;
     PFN_vkCmdSetExclusiveScissorNV            vkCmdSetExclusiveScissorNV            = 0;
+    PFN_vkCmdSetFrontFaceEXT                  vkCmdSetFrontFaceEXT                  = 0;
     PFN_vkCmdSetLineStippleEXT                vkCmdSetLineStippleEXT                = 0;
     PFN_vkCmdSetLineWidth                     vkCmdSetLineWidth                     = 0;
     PFN_vkCmdSetPerformanceMarkerINTEL        vkCmdSetPerformanceMarkerINTEL        = 0;
     PFN_vkCmdSetPerformanceOverrideINTEL      vkCmdSetPerformanceOverrideINTEL      = 0;
     PFN_vkCmdSetPerformanceStreamMarkerINTEL  vkCmdSetPerformanceStreamMarkerINTEL  = 0;
+    PFN_vkCmdSetPrimitiveTopologyEXT          vkCmdSetPrimitiveTopologyEXT          = 0;
     PFN_vkCmdSetSampleLocationsEXT            vkCmdSetSampleLocationsEXT            = 0;
     PFN_vkCmdSetScissor                       vkCmdSetScissor                       = 0;
+    PFN_vkCmdSetScissorWithCountEXT           vkCmdSetScissorWithCountEXT           = 0;
     PFN_vkCmdSetStencilCompareMask            vkCmdSetStencilCompareMask            = 0;
+    PFN_vkCmdSetStencilOpEXT                  vkCmdSetStencilOpEXT                  = 0;
     PFN_vkCmdSetStencilReference              vkCmdSetStencilReference              = 0;
+    PFN_vkCmdSetStencilTestEnableEXT          vkCmdSetStencilTestEnableEXT          = 0;
     PFN_vkCmdSetStencilWriteMask              vkCmdSetStencilWriteMask              = 0;
     PFN_vkCmdSetViewport                      vkCmdSetViewport                      = 0;
     PFN_vkCmdSetViewportShadingRatePaletteNV  vkCmdSetViewportShadingRatePaletteNV  = 0;
     PFN_vkCmdSetViewportWScalingNV            vkCmdSetViewportWScalingNV            = 0;
+    PFN_vkCmdSetViewportWithCountEXT          vkCmdSetViewportWithCountEXT          = 0;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -98244,6 +98839,8 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) );
       vkCmdBindVertexBuffers =
         PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) );
+      vkCmdBindVertexBuffers2EXT =
+        PFN_vkCmdBindVertexBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2EXT" ) );
       vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkCmdBuildAccelerationStructureIndirectKHR = PFN_vkCmdBuildAccelerationStructureIndirectKHR(
@@ -98353,8 +98950,17 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) );
       vkCmdSetCoarseSampleOrderNV =
         PFN_vkCmdSetCoarseSampleOrderNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) );
+      vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) );
       vkCmdSetDepthBias   = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) );
       vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) );
+      vkCmdSetDepthBoundsTestEnableEXT =
+        PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) );
+      vkCmdSetDepthCompareOpEXT =
+        PFN_vkCmdSetDepthCompareOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOpEXT" ) );
+      vkCmdSetDepthTestEnableEXT =
+        PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) );
+      vkCmdSetDepthWriteEnableEXT =
+        PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) );
       vkCmdSetDeviceMask    = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
       vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) );
       vkCmdSetDiscardRectangleEXT =
@@ -98362,6 +98968,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
       vkCmdSetExclusiveScissorNV =
         PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
+      vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) );
       vkCmdSetLineStippleEXT =
         PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
       vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
@@ -98371,13 +98978,20 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) );
       vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL(
         vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
+      vkCmdSetPrimitiveTopologyEXT =
+        PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) );
       vkCmdSetSampleLocationsEXT =
         PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) );
       vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) );
+      vkCmdSetScissorWithCountEXT =
+        PFN_vkCmdSetScissorWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCountEXT" ) );
       vkCmdSetStencilCompareMask =
         PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) );
+      vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOpEXT" ) );
       vkCmdSetStencilReference =
         PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) );
+      vkCmdSetStencilTestEnableEXT =
+        PFN_vkCmdSetStencilTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnableEXT" ) );
       vkCmdSetStencilWriteMask =
         PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) );
       vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) );
@@ -98385,6 +98999,8 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) );
       vkCmdSetViewportWScalingNV =
         PFN_vkCmdSetViewportWScalingNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) );
+      vkCmdSetViewportWithCountEXT =
+        PFN_vkCmdSetViewportWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCountEXT" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkCmdTraceRaysIndirectKHR =
         PFN_vkCmdTraceRaysIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirectKHR" ) );
@@ -98851,6 +99467,8 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT(
         vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) );
       vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) );
+      vkCmdBindVertexBuffers2EXT =
+        PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) );
       vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkCmdBuildAccelerationStructureIndirectKHR = PFN_vkCmdBuildAccelerationStructureIndirectKHR(
@@ -98953,8 +99571,17 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdSetCheckpointNV   = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) );
       vkCmdSetCoarseSampleOrderNV =
         PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) );
+      vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) );
       vkCmdSetDepthBias   = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
       vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
+      vkCmdSetDepthBoundsTestEnableEXT =
+        PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) );
+      vkCmdSetDepthCompareOpEXT =
+        PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) );
+      vkCmdSetDepthTestEnableEXT =
+        PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) );
+      vkCmdSetDepthWriteEnableEXT =
+        PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) );
       vkCmdSetDeviceMask    = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
       vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) );
       vkCmdSetDiscardRectangleEXT =
@@ -98962,6 +99589,7 @@ namespace VULKAN_HPP_NAMESPACE
       vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
       vkCmdSetExclusiveScissorNV =
         PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
+      vkCmdSetFrontFaceEXT   = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) );
       vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
       vkCmdSetLineWidth      = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
       vkCmdSetPerformanceMarkerINTEL =
@@ -98970,13 +99598,20 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) );
       vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL(
         vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
+      vkCmdSetPrimitiveTopologyEXT =
+        PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) );
       vkCmdSetSampleLocationsEXT =
         PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
       vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) );
+      vkCmdSetScissorWithCountEXT =
+        PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) );
       vkCmdSetStencilCompareMask =
         PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) );
+      vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) );
       vkCmdSetStencilReference =
         PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) );
+      vkCmdSetStencilTestEnableEXT =
+        PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) );
       vkCmdSetStencilWriteMask =
         PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) );
       vkCmdSetViewport                     = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) );
@@ -98984,6 +99619,8 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) );
       vkCmdSetViewportWScalingNV =
         PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) );
+      vkCmdSetViewportWithCountEXT =
+        PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) );
 #ifdef VK_ENABLE_BETA_EXTENSIONS
       vkCmdTraceRaysIndirectKHR =
         PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) );