Update for Vulkan-Docs 1.3.211

include/vulkan/vulkan.hpp

@@ -119,7 +119,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <span>
 #endif
 
-static_assert( VK_HEADER_VERSION == 210, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 211, "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
@@ -6018,25 +6018,8 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
   template <typename T, typename D>
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<T, D>>>::type
+  VULKAN_HPP_INLINE ResultValue<UniqueHandle<T, D>> createResultValue(
-    createResultValue( Result result, std::vector<UniqueHandle<T, D>> && data, char const * message )
+    Result result, T & data, char const * message, std::initializer_list<Result> successCodes, typename UniqueHandleTraits<T, D>::deleter const & deleter )
-  {
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    ignore( message );
-    VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
-    return ResultValue<std::vector<UniqueHandle<T, D>>>( result, std::move( data ) );
-#  else
-    if ( result != Result::eSuccess )
-    {
-      throwResultException( result, message );
-    }
-    return std::move( data );
-#  endif
-  }
-
-  template <typename T, typename D>
-  VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<T, D>>>
-    createResultValue( Result result, std::vector<UniqueHandle<T, D>> && data, char const * message, std::initializer_list<Result> successCodes )
   {
 #  ifdef VULKAN_HPP_NO_EXCEPTIONS
     ignore( message );
@@ -6048,7 +6031,41 @@ namespace VULKAN_HPP_NAMESPACE
       throwResultException( result, message );
     }
 #  endif
-    return ResultValue<std::vector<UniqueHandle<T, D>>>( result, std::move( data ) );
+    return ResultValue<UniqueHandle<T, D>>( result, UniqueHandle<T, D>( data, deleter ) );
+  }
+
+  template <typename T, typename D, typename Allocator = std::allocator<UniqueHandle<T, D>>>
+  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<T, D>, Allocator>>::type
+    createResultValue( Result result, std::vector<UniqueHandle<T, D>, Allocator> && data, char const * message )
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore( message );
+    VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
+    return ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>( result, std::move( data ) );
+#  else
+    if ( result != Result::eSuccess )
+    {
+      throwResultException( result, message );
+    }
+    return std::move( data );
+#  endif
+  }
+
+  template <typename T, typename D, typename Allocator = std::allocator<UniqueHandle<T, D>>>
+  VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>
+    createResultValue( Result result, std::vector<UniqueHandle<T, D>, Allocator> && data, char const * message, std::initializer_list<Result> successCodes )
+  {
+#  ifdef VULKAN_HPP_NO_EXCEPTIONS
+    ignore( message );
+    ignore( successCodes );  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+    VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
+#  else
+    if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+    {
+      throwResultException( result, message );
+    }
+#  endif
+    return ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>( result, std::move( data ) );
   }
 #endif
 
@@ -10638,6 +10655,24 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_EXT_image_2d_view_of_3d ===
+  template <>
+  struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_EXT_border_color_swizzle ===
   template <>
   struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, PhysicalDeviceFeatures2>

include/vulkan/vulkan_beta.h

@@ -315,7 +315,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(
 
 
 #define VK_KHR_video_decode_queue 1
-#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 3
+#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 4
 #define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue"
 
 typedef enum VkVideoDecodeCapabilityFlagBitsKHR {
@@ -342,8 +342,6 @@ typedef struct VkVideoDecodeInfoKHR {
     VkStructureType                   sType;
     const void*                       pNext;
     VkVideoDecodeFlagsKHR             flags;
-    VkOffset2D                        codedOffset;
-    VkExtent2D                        codedExtent;
     VkBuffer                          srcBuffer;
     VkDeviceSize                      srcBufferOffset;
     VkDeviceSize                      srcBufferRange;
@@ -394,7 +392,7 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
 
 
 #define VK_KHR_video_encode_queue 1
-#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 4
+#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 5
 #define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
 
 typedef enum VkVideoEncodeFlagBitsKHR {
@@ -430,7 +428,6 @@ typedef struct VkVideoEncodeInfoKHR {
     const void*                       pNext;
     VkVideoEncodeFlagsKHR             flags;
     uint32_t                          qualityLevel;
-    VkExtent2D                        codedExtent;
     VkBuffer                          dstBitstreamBuffer;
     VkDeviceSize                      dstBitstreamBufferOffset;
     VkDeviceSize                      dstBitstreamBufferMaxRange;
@@ -443,7 +440,7 @@ typedef struct VkVideoEncodeInfoKHR {
 
 typedef struct VkVideoEncodeCapabilitiesKHR {
     VkStructureType                         sType;
-    const void*                             pNext;
+    void*                                   pNext;
     VkVideoEncodeCapabilityFlagsKHR         flags;
     VkVideoEncodeRateControlModeFlagsKHR    rateControlModes;
     uint8_t                                 rateControlLayerCount;
@@ -539,7 +536,7 @@ typedef enum VkVideoEncodeH264RateControlStructureFlagBitsEXT {
 typedef VkFlags VkVideoEncodeH264RateControlStructureFlagsEXT;
 typedef struct VkVideoEncodeH264CapabilitiesEXT {
     VkStructureType                        sType;
-    const void*                            pNext;
+    void*                                  pNext;
     VkVideoEncodeH264CapabilityFlagsEXT    flags;
     VkVideoEncodeH264InputModeFlagsEXT     inputModeFlags;
     VkVideoEncodeH264OutputModeFlagsEXT    outputModeFlags;
@@ -660,7 +657,7 @@ typedef struct VkVideoEncodeH264RateControlLayerInfoEXT {
 #define VK_EXT_video_encode_h265 1
 #include "vk_video/vulkan_video_codec_h265std.h"
 #include "vk_video/vulkan_video_codec_h265std_encode.h"
-#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 6
+#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 7
 #define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265"
 
 typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT {
@@ -674,20 +671,22 @@ typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT {
     VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000080,
     VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT = 0x00000100,
     VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT = 0x00000200,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0x00000400,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT = 0x00000400,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00000800,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0x00000800,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0x00001000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00001000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00002000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0x00002000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0x00004000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00004000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0x00008000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0x00008000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0x00010000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0x00010000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0x00020000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0x00020000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0x00040000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0x00040000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0x00080000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0x00080000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0x00100000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0x00100000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00200000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0x00200000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0x00400000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00400000,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00800000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0x00800000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x01000000,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x02000000,
     VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
 } VkVideoEncodeH265CapabilityFlagBitsEXT;
 typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT;
@@ -734,7 +733,7 @@ typedef enum VkVideoEncodeH265RateControlStructureFlagBitsEXT {
 typedef VkFlags VkVideoEncodeH265RateControlStructureFlagsEXT;
 typedef struct VkVideoEncodeH265CapabilitiesEXT {
     VkStructureType                                sType;
-    const void*                                    pNext;
+    void*                                          pNext;
     VkVideoEncodeH265CapabilityFlagsEXT            flags;
     VkVideoEncodeH265InputModeFlagsEXT             inputModeFlags;
     VkVideoEncodeH265OutputModeFlagsEXT            outputModeFlags;
@@ -868,7 +867,7 @@ typedef struct VkVideoEncodeH265RateControlLayerInfoEXT {
 
 #define VK_EXT_video_decode_h264 1
 #include "vk_video/vulkan_video_codec_h264std_decode.h"
-#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 4
+#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 5
 #define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264"
 
 typedef enum VkVideoDecodeH264PictureLayoutFlagBitsEXT {
@@ -886,10 +885,10 @@ typedef struct VkVideoDecodeH264ProfileEXT {
 } VkVideoDecodeH264ProfileEXT;
 
 typedef struct VkVideoDecodeH264CapabilitiesEXT {
-    VkStructureType    sType;
+    VkStructureType      sType;
-    void*              pNext;
+    void*                pNext;
-    uint32_t           maxLevel;
+    StdVideoH264Level    maxLevel;
-    VkOffset2D         fieldOffsetGranularity;
+    VkOffset2D           fieldOffsetGranularity;
 } VkVideoDecodeH264CapabilitiesEXT;
 
 typedef struct VkVideoDecodeH264SessionParametersAddInfoEXT {
@@ -933,7 +932,7 @@ typedef struct VkVideoDecodeH264DpbSlotInfoEXT {
 
 #define VK_EXT_video_decode_h265 1
 #include "vk_video/vulkan_video_codec_h265std_decode.h"
-#define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 2
+#define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 3
 #define VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME "VK_EXT_video_decode_h265"
 typedef struct VkVideoDecodeH265ProfileEXT {
     VkStructureType           sType;
@@ -942,9 +941,9 @@ typedef struct VkVideoDecodeH265ProfileEXT {
 } VkVideoDecodeH265ProfileEXT;
 
 typedef struct VkVideoDecodeH265CapabilitiesEXT {
-    VkStructureType    sType;
+    VkStructureType      sType;
-    void*              pNext;
+    void*                pNext;
-    uint32_t           maxLevel;
+    StdVideoH265Level    maxLevel;
 } VkVideoDecodeH265CapabilitiesEXT;
 
 typedef struct VkVideoDecodeH265SessionParametersAddInfoEXT {

include/vulkan/vulkan_core.h

@@ -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 210
+#define VK_HEADER_VERSION 211
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@@ -931,6 +931,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000,
     VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000,
@@ -2073,6 +2074,7 @@ typedef enum VkImageCreateFlagBits {
     VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
     VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
     VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
+    VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000,
     VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000,
     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
@@ -13849,6 +13851,18 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(
 #endif
 
 
+#define VK_EXT_image_2d_view_of_3d 1
+#define VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION 1
+#define VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_2d_view_of_3d"
+typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           image2DViewOf3D;
+    VkBool32           sampler2DViewOf3D;
+} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT;
+
+
+
 #define VK_EXT_load_store_op_none 1
 #define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1
 #define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none"

include/vulkan/vulkan_enums.hpp

@@ -812,6 +812,7 @@ namespace VULKAN_HPP_NAMESPACE
     eImageViewMinLodCreateInfoEXT                            = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT,
     ePhysicalDeviceMultiDrawFeaturesEXT                      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT,
     ePhysicalDeviceMultiDrawPropertiesEXT                    = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT,
+    ePhysicalDeviceImage2DViewOf3DFeaturesEXT                = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT,
     ePhysicalDeviceBorderColorSwizzleFeaturesEXT             = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT,
     eSamplerBorderColorComponentMappingCreateInfoEXT         = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT,
     ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT,
@@ -1671,6 +1672,7 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eImageViewMinLodCreateInfoEXT: return "ImageViewMinLodCreateInfoEXT";
       case StructureType::ePhysicalDeviceMultiDrawFeaturesEXT: return "PhysicalDeviceMultiDrawFeaturesEXT";
       case StructureType::ePhysicalDeviceMultiDrawPropertiesEXT: return "PhysicalDeviceMultiDrawPropertiesEXT";
+      case StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT: return "PhysicalDeviceImage2DViewOf3DFeaturesEXT";
       case StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT: return "PhysicalDeviceBorderColorSwizzleFeaturesEXT";
       case StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT: return "SamplerBorderColorComponentMappingCreateInfoEXT";
       case StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT: return "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT";
@@ -2511,6 +2513,7 @@ namespace VULKAN_HPP_NAMESPACE
     eCornerSampledNV                   = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV,
     eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT,
     eSubsampledEXT                     = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT,
+    e2DViewCompatibleEXT               = VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT,
     eFragmentDensityMapOffsetQCOM      = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM,
     e2DArrayCompatibleKHR              = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR,
     eAliasKHR                          = VK_IMAGE_CREATE_ALIAS_BIT_KHR,
@@ -2539,6 +2542,7 @@ namespace VULKAN_HPP_NAMESPACE
       case ImageCreateFlagBits::eCornerSampledNV: return "CornerSampledNV";
       case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT";
       case ImageCreateFlagBits::eSubsampledEXT: return "SubsampledEXT";
+      case ImageCreateFlagBits::e2DViewCompatibleEXT: return "2DViewCompatibleEXT";
       case ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM: return "FragmentDensityMapOffsetQCOM";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
@@ -6354,6 +6358,7 @@ namespace VULKAN_HPP_NAMESPACE
     eLog2ParallelMergeLevelMinus2    = VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT,
     eSignDataHidingEnabled           = VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT,
     eTransformSkipEnabled            = VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT,
+    eTransformSkipDisabled           = VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT,
     ePpsSliceChromaQpOffsetsPresent  = VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT,
     eWeightedPred                    = VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT,
     eWeightedBipred                  = VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT,
@@ -6367,7 +6372,8 @@ namespace VULKAN_HPP_NAMESPACE
     eSliceSegmentCtbCount            = VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT,
     eRowUnalignedSliceSegment        = VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT,
     eDependentSliceSegment           = VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT,
-    eDifferentSliceType              = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT
+    eDifferentSliceType              = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT,
+    eBFrameInL1List                  = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagBitsEXT value )
@@ -6384,6 +6390,7 @@ namespace VULKAN_HPP_NAMESPACE
       case VideoEncodeH265CapabilityFlagBitsEXT::eLog2ParallelMergeLevelMinus2: return "Log2ParallelMergeLevelMinus2";
       case VideoEncodeH265CapabilityFlagBitsEXT::eSignDataHidingEnabled: return "SignDataHidingEnabled";
       case VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled: return "TransformSkipEnabled";
+      case VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipDisabled: return "TransformSkipDisabled";
       case VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent: return "PpsSliceChromaQpOffsetsPresent";
       case VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred: return "WeightedPred";
       case VideoEncodeH265CapabilityFlagBitsEXT::eWeightedBipred: return "WeightedBipred";
@@ -6398,6 +6405,7 @@ namespace VULKAN_HPP_NAMESPACE
       case VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment: return "RowUnalignedSliceSegment";
       case VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment: return "DependentSliceSegment";
       case VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType: return "DifferentSliceType";
+      case VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List: return "BFrameInL1List";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -8461,7 +8469,7 @@ namespace VULKAN_HPP_NAMESPACE
                  VkFlags( ImageCreateFlagBits::eBlockTexelViewCompatible ) | VkFlags( ImageCreateFlagBits::eExtendedUsage ) |
                  VkFlags( ImageCreateFlagBits::eProtected ) | VkFlags( ImageCreateFlagBits::eDisjoint ) | VkFlags( ImageCreateFlagBits::eCornerSampledNV ) |
                  VkFlags( ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) | VkFlags( ImageCreateFlagBits::eSubsampledEXT ) |
-                 VkFlags( ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM )
+                 VkFlags( ImageCreateFlagBits::e2DViewCompatibleEXT ) | VkFlags( ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM )
     };
   };
 
@@ -8521,6 +8529,8 @@ namespace VULKAN_HPP_NAMESPACE
       result += "SampleLocationsCompatibleDepthEXT | ";
     if ( value & ImageCreateFlagBits::eSubsampledEXT )
       result += "SubsampledEXT | ";
+    if ( value & ImageCreateFlagBits::e2DViewCompatibleEXT )
+      result += "2DViewCompatibleEXT | ";
     if ( value & ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM )
       result += "FragmentDensityMapOffsetQCOM | ";
 
@@ -13555,6 +13565,7 @@ namespace VULKAN_HPP_NAMESPACE
         VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSpsTemporalMvpEnabled ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance ) |
         VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eInitQpMinus26 ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eLog2ParallelMergeLevelMinus2 ) |
         VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSignDataHidingEnabled ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled ) |
+        VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipDisabled ) |
         VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred ) |
         VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eWeightedBipred ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPredNoTable ) |
         VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eTransquantBypassEnabled ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eEntropyCodingSyncEnabled ) |
@@ -13562,7 +13573,7 @@ namespace VULKAN_HPP_NAMESPACE
         VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerFrame ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSlicePerTile ) |
         VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerSlice ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eSliceSegmentCtbCount ) |
         VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment ) |
-        VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType )
+        VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType ) | VkFlags( VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List )
     };
   };
 
@@ -13615,6 +13626,8 @@ namespace VULKAN_HPP_NAMESPACE
       result += "SignDataHidingEnabled | ";
     if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled )
       result += "TransformSkipEnabled | ";
+    if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipDisabled )
+      result += "TransformSkipDisabled | ";
     if ( value & VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent )
       result += "PpsSliceChromaQpOffsetsPresent | ";
     if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred )
@@ -13643,6 +13656,8 @@ namespace VULKAN_HPP_NAMESPACE
       result += "DependentSliceSegment | ";
     if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType )
       result += "DifferentSliceType | ";
+    if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List )
+      result += "BFrameInL1List | ";
 
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }

include/vulkan/vulkan_funcs.hpp

@@ -1836,8 +1836,8 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DataType, typename Allocator, typename Dispatch>
+  template <typename DataType, typename DataTypeAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<DataType, Allocator>>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<DataType, DataTypeAllocator>>
                                          Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
                                  uint32_t                               firstQuery,
                                  uint32_t                               queryCount,
@@ -1848,8 +1848,8 @@ namespace VULKAN_HPP_NAMESPACE
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
-    std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
+    std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
-    Result                           result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
+    Result                                   result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
                                                                   static_cast<VkQueryPool>( queryPool ),
                                                                   firstQuery,
                                                                   queryCount,
@@ -2623,18 +2623,19 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
-    Result                                                         result = static_cast<Result>( d.vkCreateGraphicsPipelines(
+    VkResult                                                       result = d.vkCreateGraphicsPipelines(
       m_device,
       static_cast<VkPipelineCache>( pipelineCache ),
       createInfos.size(),
       reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      reinterpret_cast<VkPipeline *>( pipelines.data() ) );
-    return createResultValue( result,
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
-                              pipelines,
+                 VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
+                 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+    return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), pipelines );
   }
 
   template <typename PipelineAllocator,
@@ -2649,18 +2650,19 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const &                                                           d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
-    Result                                                         result = static_cast<Result>( d.vkCreateGraphicsPipelines(
+    VkResult                                                       result = d.vkCreateGraphicsPipelines(
       m_device,
       static_cast<VkPipelineCache>( pipelineCache ),
       createInfos.size(),
       reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      reinterpret_cast<VkPipeline *>( pipelines.data() ) );
-    return createResultValue( result,
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
-                              pipelines,
+                 VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines",
+                 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+    return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), pipelines );
   }
 
   template <typename Dispatch>
@@ -2807,18 +2809,19 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
-    Result                                                         result = static_cast<Result>( d.vkCreateComputePipelines(
+    VkResult                                                       result = d.vkCreateComputePipelines(
       m_device,
       static_cast<VkPipelineCache>( pipelineCache ),
       createInfos.size(),
       reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      reinterpret_cast<VkPipeline *>( pipelines.data() ) );
-    return createResultValue( result,
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
-                              pipelines,
+                 VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines",
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines",
+                 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+    return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), pipelines );
   }
 
   template <typename PipelineAllocator,
@@ -2833,18 +2836,19 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                                          d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
-    Result                                                         result = static_cast<Result>( d.vkCreateComputePipelines(
+    VkResult                                                       result = d.vkCreateComputePipelines(
       m_device,
       static_cast<VkPipelineCache>( pipelineCache ),
       createInfos.size(),
       reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      reinterpret_cast<VkPipeline *>( pipelines.data() ) );
-    return createResultValue( result,
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
-                              pipelines,
+                 VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines",
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines",
+                 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+    return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), pipelines );
   }
 
   template <typename Dispatch>
@@ -3444,10 +3448,12 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount );
-    Result                                                                   result = static_cast<Result>( d.vkAllocateDescriptorSets(
+    VkResult                                                                 result = d.vkAllocateDescriptorSets(
-      m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
+      m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) );
-    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
+    return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), descriptorSets );
   }
 
   template <typename DescriptorSetAllocator,
@@ -3460,10 +3466,12 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount, descriptorSetAllocator );
-    Result                                                                   result = static_cast<Result>( d.vkAllocateDescriptorSets(
+    VkResult                                                                 result = d.vkAllocateDescriptorSets(
-      m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
+      m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) );
-    return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" );
+    return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), descriptorSets );
   }
 
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
@@ -3953,10 +3961,12 @@ namespace VULKAN_HPP_NAMESPACE
                        Device::allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount );
-    Result                                                                   result = static_cast<Result>( d.vkAllocateCommandBuffers(
+    VkResult                                                                 result = d.vkAllocateCommandBuffers(
-      m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
+      m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) );
-    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
+    return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), commandBuffers );
   }
 
   template <typename CommandBufferAllocator,
@@ -3969,10 +3979,12 @@ namespace VULKAN_HPP_NAMESPACE
                                     Dispatch const &                                        d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount, commandBufferAllocator );
-    Result                                                                   result = static_cast<Result>( d.vkAllocateCommandBuffers(
+    VkResult                                                                 result = d.vkAllocateCommandBuffers(
-      m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
+      m_device, reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) );
-    return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" );
+    return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), commandBuffers );
   }
 
 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
@@ -8275,14 +8287,16 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() );
-    Result                                                                 result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR(
+    VkResult                                                               result = d.vkCreateSharedSwapchainsKHR(
       m_device,
       createInfos.size(),
       reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
+      reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) );
-    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
+    return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), swapchains );
   }
 
   template <typename SwapchainKHRAllocator,
@@ -8296,14 +8310,16 @@ namespace VULKAN_HPP_NAMESPACE
                                        Dispatch const &                                                       d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(), swapchainKHRAllocator );
-    Result                                                                 result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR(
+    VkResult                                                               result = d.vkCreateSharedSwapchainsKHR(
       m_device,
       createInfos.size(),
       reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
+      reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) );
-    return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" );
+    return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), swapchains );
   }
 
   template <typename Dispatch>
@@ -13596,8 +13612,8 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DataType, typename Allocator, typename Dispatch>
+  template <typename DataType, typename DataTypeAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, Allocator>>::type
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
     Device::writeAccelerationStructuresPropertiesKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
                                                       VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
                                                       size_t                                                                   dataSize,
@@ -13606,8 +13622,8 @@ namespace VULKAN_HPP_NAMESPACE
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
-    std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
+    std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
-    Result                           result =
+    Result                                   result =
       static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( m_device,
                                                                          accelerationStructures.size(),
                                                                          reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
@@ -14545,18 +14561,19 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
-    Result                                                         result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV(
+    VkResult                                                       result = d.vkCreateRayTracingPipelinesNV(
       m_device,
       static_cast<VkPipelineCache>( pipelineCache ),
       createInfos.size(),
       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      reinterpret_cast<VkPipeline *>( pipelines.data() ) );
-    return createResultValue( result,
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
-                              pipelines,
+                 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
+                 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+    return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), pipelines );
   }
 
   template <typename PipelineAllocator,
@@ -14571,18 +14588,19 @@ namespace VULKAN_HPP_NAMESPACE
                                          Dispatch const &                                                               d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
-    Result                                                         result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV(
+    VkResult                                                       result = d.vkCreateRayTracingPipelinesNV(
       m_device,
       static_cast<VkPipelineCache>( pipelineCache ),
       createInfos.size(),
       reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      reinterpret_cast<VkPipeline *>( pipelines.data() ) );
-    return createResultValue( result,
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
-                              pipelines,
+                 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV",
+                 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+    return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), pipelines );
   }
 
   template <typename Dispatch>
@@ -14717,14 +14735,14 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DataType, typename Allocator, typename Dispatch>
+  template <typename DataType, typename DataTypeAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, Allocator>>::type Device::getRayTracingShaderGroupHandlesNV(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type Device::getRayTracingShaderGroupHandlesNV(
     VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
-    std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
+    std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
-    Result                           result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV(
+    Result                                   result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV(
       m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) );
     return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
   }
@@ -14755,14 +14773,14 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DataType, typename Allocator, typename Dispatch>
+  template <typename DataType, typename DataTypeAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, Allocator>>::type
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
     Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
-    std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
+    std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
-    Result                           result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV(
+    Result                                   result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV(
       m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) );
     return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
   }
@@ -15883,7 +15901,7 @@ namespace VULKAN_HPP_NAMESPACE
     VkResult result = d.vkWaitForPresentKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), presentId, timeout );
     resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
                  VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR",
-                 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
+                 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
     return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@@ -17865,22 +17883,23 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
-    Result                                                         result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR(
+    VkResult                                                       result = d.vkCreateRayTracingPipelinesKHR(
       m_device,
       static_cast<VkDeferredOperationKHR>( deferredOperation ),
       static_cast<VkPipelineCache>( pipelineCache ),
       createInfos.size(),
       reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      reinterpret_cast<VkPipeline *>( pipelines.data() ) );
-    return createResultValue( result,
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
-                              pipelines,
+                 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR",
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR",
+                 { VULKAN_HPP_NAMESPACE::Result::eSuccess,
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
+                   VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
+                   VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR,
+                   VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-                                VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+    return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), pipelines );
   }
 
   template <typename PipelineAllocator,
@@ -17896,22 +17915,23 @@ namespace VULKAN_HPP_NAMESPACE
                                           Dispatch const &                                                                d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+
     std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
-    Result                                                         result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR(
+    VkResult                                                       result = d.vkCreateRayTracingPipelinesKHR(
       m_device,
       static_cast<VkDeferredOperationKHR>( deferredOperation ),
       static_cast<VkPipelineCache>( pipelineCache ),
       createInfos.size(),
       reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ),
       reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
-      reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
+      reinterpret_cast<VkPipeline *>( pipelines.data() ) );
-    return createResultValue( result,
+    resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
-                              pipelines,
+                 VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR",
-                              VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR",
+                 { VULKAN_HPP_NAMESPACE::Result::eSuccess,
-                              { VULKAN_HPP_NAMESPACE::Result::eSuccess,
+                   VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
+                   VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR,
-                                VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR,
+                   VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
-                                VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
+    return ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), pipelines );
   }
 
   template <typename Dispatch>
@@ -18068,14 +18088,14 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DataType, typename Allocator, typename Dispatch>
+  template <typename DataType, typename DataTypeAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, Allocator>>::type Device::getRayTracingShaderGroupHandlesKHR(
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type Device::getRayTracingShaderGroupHandlesKHR(
     VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
-    std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
+    std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
-    Result                           result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR(
+    Result                                   result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR(
       m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) );
     return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
   }
@@ -18108,15 +18128,15 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename DataType, typename Allocator, typename Dispatch>
+  template <typename DataType, typename DataTypeAllocator, typename Dispatch>
-  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, Allocator>>::type
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
                        Device::getRayTracingCaptureReplayShaderGroupHandlesKHR(
       VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
     VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
-    std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
+    std::vector<DataType, DataTypeAllocator> data( dataSize / sizeof( DataType ) );
-    Result                           result = static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+    Result                                   result = static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
       m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast<void *>( data.data() ) ) );
     return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" );
   }

include/vulkan/vulkan_handles.hpp

@@ -1339,6 +1339,9 @@ namespace VULKAN_HPP_NAMESPACE
   struct MultiDrawInfoEXT;
   struct MultiDrawIndexedInfoEXT;
 
+  //=== VK_EXT_image_2d_view_of_3d ===
+  struct PhysicalDeviceImage2DViewOf3DFeaturesEXT;
+
   //=== VK_EXT_border_color_swizzle ===
   struct PhysicalDeviceBorderColorSwizzleFeaturesEXT;
   struct SamplerBorderColorComponentMappingCreateInfoEXT;
@@ -7595,8 +7598,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                      VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DataType, typename Allocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, Allocator>>
+    VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, DataTypeAllocator>>
                          getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
                                               uint32_t                                     firstQuery,
                                               uint32_t                                     queryCount,
@@ -9976,8 +9979,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                 size_t                                                 stride,
                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DataType, typename Allocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, Allocator>>::type
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
       writeAccelerationStructuresPropertiesKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
                                                 VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
                                                 size_t                                                                   dataSize,
@@ -10306,8 +10309,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                                    void *                         pData,
                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DataType, typename Allocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, Allocator>>::type
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
                                          uint32_t                       firstGroup,
                                          uint32_t                       groupCount,
@@ -10324,8 +10327,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                                   void *                                        pData,
                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DataType, typename Allocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, Allocator>>::type getAccelerationStructureHandleNV(
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type getAccelerationStructureHandleNV(
       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD typename ResultValueType<DataType>::type
@@ -10935,8 +10938,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                                     void *                         pData,
                                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DataType, typename Allocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, Allocator>>::type
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
                                           uint32_t                       firstGroup,
                                           uint32_t                       groupCount,
@@ -10956,8 +10959,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                        void *                         pData,
                                                        Dispatch const & d             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename DataType, typename Allocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, Allocator>>::type
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DataType, DataTypeAllocator>>::type
       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
                                                        uint32_t                       firstGroup,
                                                        uint32_t                       groupCount,

include/vulkan/vulkan_hash.hpp

@@ -6905,6 +6905,21 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT>
   {
@@ -11709,8 +11724,6 @@ namespace std
       VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType );
       VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext );
       VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags );
-      VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.codedOffset );
-      VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.codedExtent );
       VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer );
       VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset );
       VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange );
@@ -12245,7 +12258,6 @@ namespace std
       VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext );
       VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags );
       VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.qualityLevel );
-      VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.codedExtent );
       VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBitstreamBuffer );
       VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBitstreamBufferOffset );
       VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBitstreamBufferMaxRange );

include/vulkan/vulkan_raii.hpp

@@ -15949,7 +15949,8 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
         getDispatcher()->vkWaitForPresentKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), presentId, timeout ) );
-      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) )
+      if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) &&
+           ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) )
       {
         throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::waitForPresent" );
       }

include/vulkan/vulkan_structs.hpp

@@ -52840,6 +52840,119 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
 
+  struct PhysicalDeviceImage2DViewOf3DFeaturesEXT
+  {
+    using NativeType = VkPhysicalDeviceImage2DViewOf3DFeaturesEXT;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceImage2DViewOf3DFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 image2DViewOf3D_   = {},
+                                                                   VULKAN_HPP_NAMESPACE::Bool32 sampler2DViewOf3D_ = {},
+                                                                   void *                       pNext_             = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext( pNext_ )
+      , image2DViewOf3D( image2DViewOf3D_ )
+      , sampler2DViewOf3D( sampler2DViewOf3D_ )
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceImage2DViewOf3DFeaturesEXT( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceImage2DViewOf3DFeaturesEXT( VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceImage2DViewOf3DFeaturesEXT( *reinterpret_cast<PhysicalDeviceImage2DViewOf3DFeaturesEXT const *>( &rhs ) )
+    {
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceImage2DViewOf3DFeaturesEXT & operator=( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceImage2DViewOf3DFeaturesEXT & operator=( VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT & setImage2DViewOf3D( VULKAN_HPP_NAMESPACE::Bool32 image2DViewOf3D_ ) VULKAN_HPP_NOEXCEPT
+    {
+      image2DViewOf3D = image2DViewOf3D_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT &
+                            setSampler2DViewOf3D( VULKAN_HPP_NAMESPACE::Bool32 sampler2DViewOf3D_ ) VULKAN_HPP_NOEXCEPT
+    {
+      sampler2DViewOf3D = sampler2DViewOf3D_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    explicit operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>( this );
+    }
+
+    explicit operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, image2DViewOf3D, sampler2DViewOf3D );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image2DViewOf3D == rhs.image2DViewOf3D ) && ( sampler2DViewOf3D == rhs.sampler2DViewOf3D );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType             = StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT;
+    void *                              pNext             = {};
+    VULKAN_HPP_NAMESPACE::Bool32        image2DViewOf3D   = {};
+    VULKAN_HPP_NAMESPACE::Bool32        sampler2DViewOf3D = {};
+  };
+  VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT ) == sizeof( VkPhysicalDeviceImage2DViewOf3DFeaturesEXT ),
+                            "struct and wrapper have different size!" );
+  VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT>::value,
+                            "struct wrapper is not a standard layout!" );
+  VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT>::value,
+                            "PhysicalDeviceImage2DViewOf3DFeaturesEXT is not nothrow_move_constructible!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT>
+  {
+    using Type = PhysicalDeviceImage2DViewOf3DFeaturesEXT;
+  };
+
   struct PhysicalDeviceImageDrmFormatModifierInfoEXT
   {
     using NativeType = VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
@@ -88691,7 +88804,7 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eVideoDecodeH264CapabilitiesEXT;
 
 #  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-    VULKAN_HPP_CONSTEXPR VideoDecodeH264CapabilitiesEXT( uint32_t                       maxLevel_               = {},
+    VULKAN_HPP_CONSTEXPR VideoDecodeH264CapabilitiesEXT( StdVideoH264Level              maxLevel_               = {},
                                                          VULKAN_HPP_NAMESPACE::Offset2D fieldOffsetGranularity_ = {},
                                                          void *                         pNext_                  = nullptr ) VULKAN_HPP_NOEXCEPT
       : pNext( pNext_ )
@@ -88730,7 +88843,7 @@ namespace VULKAN_HPP_NAMESPACE
 #    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
 #    else
-    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, VULKAN_HPP_NAMESPACE::Offset2D const &>
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, StdVideoH264Level const &, VULKAN_HPP_NAMESPACE::Offset2D const &>
 #    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
@@ -88739,27 +88852,36 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-    auto operator<=>( VideoDecodeH264CapabilitiesEXT const & ) const = default;
+    std::strong_ordering operator<=>( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
-#  else
+    {
+      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
+        return cmp;
+      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
+        return cmp;
+      if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoH264Level ) ); cmp != 0 )
+        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+      if ( auto cmp = fieldOffsetGranularity <=> rhs.fieldOffsetGranularity; cmp != 0 )
+        return cmp;
+
+      return std::strong_ordering::equivalent;
+    }
+#  endif
+
     bool operator==( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-#    if defined( VULKAN_HPP_USE_REFLECT )
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoH264Level ) ) == 0 ) &&
-      return this->reflect() == rhs.reflect();
+             ( fieldOffsetGranularity == rhs.fieldOffsetGranularity );
-#    else
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) && ( fieldOffsetGranularity == rhs.fieldOffsetGranularity );
-#    endif
     }
 
     bool operator!=( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
       return !operator==( rhs );
     }
-#  endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType                  = StructureType::eVideoDecodeH264CapabilitiesEXT;
     void *                              pNext                  = {};
-    uint32_t                            maxLevel               = {};
+    StdVideoH264Level                   maxLevel               = {};
     VULKAN_HPP_NAMESPACE::Offset2D      fieldOffsetGranularity = {};
   };
   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT ) == sizeof( VkVideoDecodeH264CapabilitiesEXT ),
@@ -89571,7 +89693,7 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eVideoDecodeH265CapabilitiesEXT;
 
 #  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-    VULKAN_HPP_CONSTEXPR VideoDecodeH265CapabilitiesEXT( uint32_t maxLevel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR VideoDecodeH265CapabilitiesEXT( StdVideoH265Level maxLevel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
       : pNext( pNext_ )
       , maxLevel( maxLevel_ )
     {
@@ -89607,7 +89729,7 @@ namespace VULKAN_HPP_NAMESPACE
 #    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
 #    else
-    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, StdVideoH265Level const &>
 #    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
@@ -89616,27 +89738,33 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-    auto operator<=>( VideoDecodeH265CapabilitiesEXT const & ) const = default;
+    std::strong_ordering operator<=>( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
-#  else
+    {
+      if ( auto cmp = sType <=> rhs.sType; cmp != 0 )
+        return cmp;
+      if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 )
+        return cmp;
+      if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoH265Level ) ); cmp != 0 )
+        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+
+      return std::strong_ordering::equivalent;
+    }
+#  endif
+
     bool operator==( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-#    if defined( VULKAN_HPP_USE_REFLECT )
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoH265Level ) ) == 0 );
-      return this->reflect() == rhs.reflect();
-#    else
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel );
-#    endif
     }
 
     bool operator!=( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
       return !operator==( rhs );
     }
-#  endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType    = StructureType::eVideoDecodeH265CapabilitiesEXT;
     void *                              pNext    = {};
-    uint32_t                            maxLevel = {};
+    StdVideoH265Level                   maxLevel = {};
   };
   VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT ) == sizeof( VkVideoDecodeH265CapabilitiesEXT ),
                             "struct and wrapper have different size!" );
@@ -90371,8 +90499,6 @@ namespace VULKAN_HPP_NAMESPACE
 
 #  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
     VULKAN_HPP_CONSTEXPR VideoDecodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR           flags_               = {},
-                                             VULKAN_HPP_NAMESPACE::Offset2D                      codedOffset_         = {},
-                                             VULKAN_HPP_NAMESPACE::Extent2D                      codedExtent_         = {},
                                              VULKAN_HPP_NAMESPACE::Buffer                        srcBuffer_           = {},
                                              VULKAN_HPP_NAMESPACE::DeviceSize                    srcBufferOffset_     = {},
                                              VULKAN_HPP_NAMESPACE::DeviceSize                    srcBufferRange_      = {},
@@ -90383,8 +90509,6 @@ namespace VULKAN_HPP_NAMESPACE
                                              const void *                                        pNext_               = nullptr ) VULKAN_HPP_NOEXCEPT
       : pNext( pNext_ )
       , flags( flags_ )
-      , codedOffset( codedOffset_ )
-      , codedExtent( codedExtent_ )
       , srcBuffer( srcBuffer_ )
       , srcBufferOffset( srcBufferOffset_ )
       , srcBufferRange( srcBufferRange_ )
@@ -90401,8 +90525,6 @@ namespace VULKAN_HPP_NAMESPACE
 
 #    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoDecodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR                                                                flags_,
-                        VULKAN_HPP_NAMESPACE::Offset2D                                                                           codedOffset_,
-                        VULKAN_HPP_NAMESPACE::Extent2D                                                                           codedExtent_,
                         VULKAN_HPP_NAMESPACE::Buffer                                                                             srcBuffer_,
                         VULKAN_HPP_NAMESPACE::DeviceSize                                                                         srcBufferOffset_,
                         VULKAN_HPP_NAMESPACE::DeviceSize                                                                         srcBufferRange_,
@@ -90412,8 +90534,6 @@ namespace VULKAN_HPP_NAMESPACE
                         const void *                                                                                             pNext_ = nullptr )
       : pNext( pNext_ )
       , flags( flags_ )
-      , codedOffset( codedOffset_ )
-      , codedExtent( codedExtent_ )
       , srcBuffer( srcBuffer_ )
       , srcBufferOffset( srcBufferOffset_ )
       , srcBufferRange( srcBufferRange_ )
@@ -90447,18 +90567,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setCodedOffset( VULKAN_HPP_NAMESPACE::Offset2D const & codedOffset_ ) VULKAN_HPP_NOEXCEPT
-    {
-      codedOffset = codedOffset_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setCodedExtent( VULKAN_HPP_NAMESPACE::Extent2D const & codedExtent_ ) VULKAN_HPP_NOEXCEPT
-    {
-      codedExtent = codedExtent_;
-      return *this;
-    }
-
     VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setSrcBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer_ ) VULKAN_HPP_NOEXCEPT
     {
       srcBuffer = srcBuffer_;
@@ -90531,8 +90639,6 @@ namespace VULKAN_HPP_NAMESPACE
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR const &,
-               VULKAN_HPP_NAMESPACE::Offset2D const &,
-               VULKAN_HPP_NAMESPACE::Extent2D const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
@@ -90543,18 +90649,8 @@ namespace VULKAN_HPP_NAMESPACE
 #    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
-      return std::tie( sType,
+      return std::tie(
-                       pNext,
+        sType, pNext, flags, srcBuffer, srcBufferOffset, srcBufferRange, dstPictureResource, pSetupReferenceSlot, referenceSlotCount, pReferenceSlots );
-                       flags,
-                       codedOffset,
-                       codedExtent,
-                       srcBuffer,
-                       srcBufferOffset,
-                       srcBufferRange,
-                       dstPictureResource,
-                       pSetupReferenceSlot,
-                       referenceSlotCount,
-                       pReferenceSlots );
     }
 #  endif
 
@@ -90566,9 +90662,8 @@ namespace VULKAN_HPP_NAMESPACE
 #    if defined( VULKAN_HPP_USE_REFLECT )
       return this->reflect() == rhs.reflect();
 #    else
-      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( codedOffset == rhs.codedOffset ) &&
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcBuffer == rhs.srcBuffer ) &&
-             ( codedExtent == rhs.codedExtent ) && ( srcBuffer == rhs.srcBuffer ) && ( srcBufferOffset == rhs.srcBufferOffset ) &&
+             ( srcBufferOffset == rhs.srcBufferOffset ) && ( srcBufferRange == rhs.srcBufferRange ) && ( dstPictureResource == rhs.dstPictureResource ) &&
-             ( srcBufferRange == rhs.srcBufferRange ) && ( dstPictureResource == rhs.dstPictureResource ) &&
              ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) &&
              ( pReferenceSlots == rhs.pReferenceSlots );
 #    endif
@@ -90584,8 +90679,6 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::StructureType                 sType               = StructureType::eVideoDecodeInfoKHR;
     const void *                                        pNext               = {};
     VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR           flags               = {};
-    VULKAN_HPP_NAMESPACE::Offset2D                      codedOffset         = {};
-    VULKAN_HPP_NAMESPACE::Extent2D                      codedExtent         = {};
     VULKAN_HPP_NAMESPACE::Buffer                        srcBuffer           = {};
     VULKAN_HPP_NAMESPACE::DeviceSize                    srcBufferOffset     = {};
     VULKAN_HPP_NAMESPACE::DeviceSize                    srcBufferRange      = {};
@@ -90620,7 +90713,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                      uint8_t                                                  rateControlLayerCount_       = {},
                                                      uint8_t                                                  qualityLevelCount_           = {},
                                                      VULKAN_HPP_NAMESPACE::Extent2D                           inputImageDataFillAlignment_ = {},
-                                                     const void *                                             pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+                                                     void *                                                   pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
       : pNext( pNext_ )
       , flags( flags_ )
       , rateControlModes( rateControlModes_ )
@@ -90646,46 +90739,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR &
-                            setRateControlModes( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes_ ) VULKAN_HPP_NOEXCEPT
-    {
-      rateControlModes = rateControlModes_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & setRateControlLayerCount( uint8_t rateControlLayerCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      rateControlLayerCount = rateControlLayerCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR & setQualityLevelCount( uint8_t qualityLevelCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      qualityLevelCount = qualityLevelCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeCapabilitiesKHR &
-                            setInputImageDataFillAlignment( VULKAN_HPP_NAMESPACE::Extent2D const & inputImageDataFillAlignment_ ) VULKAN_HPP_NOEXCEPT
-    {
-      inputImageDataFillAlignment = inputImageDataFillAlignment_;
-      return *this;
-    }
-#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
     explicit operator VkVideoEncodeCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>( this );
@@ -90701,7 +90754,7 @@ namespace VULKAN_HPP_NAMESPACE
     auto
 #    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
-               const void * const &,
+               void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR const &,
                uint8_t const &,
@@ -90736,7 +90789,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType                      sType                       = StructureType::eVideoEncodeCapabilitiesKHR;
-    const void *                                             pNext                       = {};
+    void *                                                   pNext                       = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeCapabilityFlagsKHR      flags                       = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagsKHR rateControlModes            = {};
     uint8_t                                                  rateControlLayerCount       = {};
@@ -90776,7 +90829,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                          uint32_t                                                maxBitsPerMbDenom_                  = {},
                                                          uint32_t                                                log2MaxMvLengthHorizontal_          = {},
                                                          uint32_t                                                log2MaxMvLengthVertical_            = {},
-                                                         const void *                                            pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+                                                         void *                                                  pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
       : pNext( pNext_ )
       , flags( flags_ )
       , inputModeFlags( inputModeFlags_ )
@@ -90808,83 +90861,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT &
-                            setInputModeFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags_ ) VULKAN_HPP_NOEXCEPT
-    {
-      inputModeFlags = inputModeFlags_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT &
-                            setOutputModeFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags_ ) VULKAN_HPP_NOEXCEPT
-    {
-      outputModeFlags = outputModeFlags_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setMaxPPictureL0ReferenceCount( uint8_t maxPPictureL0ReferenceCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxPPictureL0ReferenceCount = maxPPictureL0ReferenceCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setMaxBPictureL0ReferenceCount( uint8_t maxBPictureL0ReferenceCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxBPictureL0ReferenceCount = maxBPictureL0ReferenceCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setMaxL1ReferenceCount( uint8_t maxL1ReferenceCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxL1ReferenceCount = maxL1ReferenceCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT &
-                            setMotionVectorsOverPicBoundariesFlag( VULKAN_HPP_NAMESPACE::Bool32 motionVectorsOverPicBoundariesFlag_ ) VULKAN_HPP_NOEXCEPT
-    {
-      motionVectorsOverPicBoundariesFlag = motionVectorsOverPicBoundariesFlag_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setMaxBytesPerPicDenom( uint32_t maxBytesPerPicDenom_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxBytesPerPicDenom = maxBytesPerPicDenom_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setMaxBitsPerMbDenom( uint32_t maxBitsPerMbDenom_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxBitsPerMbDenom = maxBitsPerMbDenom_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setLog2MaxMvLengthHorizontal( uint32_t log2MaxMvLengthHorizontal_ ) VULKAN_HPP_NOEXCEPT
-    {
-      log2MaxMvLengthHorizontal = log2MaxMvLengthHorizontal_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT & setLog2MaxMvLengthVertical( uint32_t log2MaxMvLengthVertical_ ) VULKAN_HPP_NOEXCEPT
-    {
-      log2MaxMvLengthVertical = log2MaxMvLengthVertical_;
-      return *this;
-    }
-#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
     explicit operator VkVideoEncodeH264CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT *>( this );
@@ -90900,7 +90876,7 @@ namespace VULKAN_HPP_NAMESPACE
     auto
 #    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
-               const void * const &,
+               void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT const &,
@@ -90956,7 +90932,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType                     sType                              = StructureType::eVideoEncodeH264CapabilitiesEXT;
-    const void *                                            pNext                              = {};
+    void *                                                  pNext                              = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags                              = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT  inputModeFlags                     = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags                    = {};
@@ -92719,18 +92695,18 @@ namespace VULKAN_HPP_NAMESPACE
                                                          uint8_t                                                         maxBPictureL0ReferenceCount_ = {},
                                                          uint8_t                                                         maxL1ReferenceCount_         = {},
                                                          uint8_t                                                         maxSubLayersCount_           = {},
-                                                         uint8_t      minLog2MinLumaCodingBlockSizeMinus3_                                            = {},
+                                                         uint8_t minLog2MinLumaCodingBlockSizeMinus3_                                                 = {},
-                                                         uint8_t      maxLog2MinLumaCodingBlockSizeMinus3_                                            = {},
+                                                         uint8_t maxLog2MinLumaCodingBlockSizeMinus3_                                                 = {},
-                                                         uint8_t      minLog2MinLumaTransformBlockSizeMinus2_                                         = {},
+                                                         uint8_t minLog2MinLumaTransformBlockSizeMinus2_                                              = {},
-                                                         uint8_t      maxLog2MinLumaTransformBlockSizeMinus2_                                         = {},
+                                                         uint8_t maxLog2MinLumaTransformBlockSizeMinus2_                                              = {},
-                                                         uint8_t      minMaxTransformHierarchyDepthInter_                                             = {},
+                                                         uint8_t minMaxTransformHierarchyDepthInter_                                                  = {},
-                                                         uint8_t      maxMaxTransformHierarchyDepthInter_                                             = {},
+                                                         uint8_t maxMaxTransformHierarchyDepthInter_                                                  = {},
-                                                         uint8_t      minMaxTransformHierarchyDepthIntra_                                             = {},
+                                                         uint8_t minMaxTransformHierarchyDepthIntra_                                                  = {},
-                                                         uint8_t      maxMaxTransformHierarchyDepthIntra_                                             = {},
+                                                         uint8_t maxMaxTransformHierarchyDepthIntra_                                                  = {},
-                                                         uint8_t      maxDiffCuQpDeltaDepth_                                                          = {},
+                                                         uint8_t maxDiffCuQpDeltaDepth_                                                               = {},
-                                                         uint8_t      minMaxNumMergeCand_                                                             = {},
+                                                         uint8_t minMaxNumMergeCand_                                                                  = {},
-                                                         uint8_t      maxMaxNumMergeCand_                                                             = {},
+                                                         uint8_t maxMaxNumMergeCand_                                                                  = {},
-                                                         const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+                                                         void *  pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
       : pNext( pNext_ )
       , flags( flags_ )
       , inputModeFlags( inputModeFlags_ )
@@ -92771,145 +92747,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setInputModeFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT inputModeFlags_ ) VULKAN_HPP_NOEXCEPT
-    {
-      inputModeFlags = inputModeFlags_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setOutputModeFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT outputModeFlags_ ) VULKAN_HPP_NOEXCEPT
-    {
-      outputModeFlags = outputModeFlags_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setCtbSizes( VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsEXT ctbSizes_ ) VULKAN_HPP_NOEXCEPT
-    {
-      ctbSizes = ctbSizes_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setTransformBlockSizes( VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes_ ) VULKAN_HPP_NOEXCEPT
-    {
-      transformBlockSizes = transformBlockSizes_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setMaxPPictureL0ReferenceCount( uint8_t maxPPictureL0ReferenceCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxPPictureL0ReferenceCount = maxPPictureL0ReferenceCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setMaxBPictureL0ReferenceCount( uint8_t maxBPictureL0ReferenceCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxBPictureL0ReferenceCount = maxBPictureL0ReferenceCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setMaxL1ReferenceCount( uint8_t maxL1ReferenceCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxL1ReferenceCount = maxL1ReferenceCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setMaxSubLayersCount( uint8_t maxSubLayersCount_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxSubLayersCount = maxSubLayersCount_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setMinLog2MinLumaCodingBlockSizeMinus3( uint8_t minLog2MinLumaCodingBlockSizeMinus3_ ) VULKAN_HPP_NOEXCEPT
-    {
-      minLog2MinLumaCodingBlockSizeMinus3 = minLog2MinLumaCodingBlockSizeMinus3_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setMaxLog2MinLumaCodingBlockSizeMinus3( uint8_t maxLog2MinLumaCodingBlockSizeMinus3_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxLog2MinLumaCodingBlockSizeMinus3 = maxLog2MinLumaCodingBlockSizeMinus3_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setMinLog2MinLumaTransformBlockSizeMinus2( uint8_t minLog2MinLumaTransformBlockSizeMinus2_ ) VULKAN_HPP_NOEXCEPT
-    {
-      minLog2MinLumaTransformBlockSizeMinus2 = minLog2MinLumaTransformBlockSizeMinus2_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setMaxLog2MinLumaTransformBlockSizeMinus2( uint8_t maxLog2MinLumaTransformBlockSizeMinus2_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxLog2MinLumaTransformBlockSizeMinus2 = maxLog2MinLumaTransformBlockSizeMinus2_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setMinMaxTransformHierarchyDepthInter( uint8_t minMaxTransformHierarchyDepthInter_ ) VULKAN_HPP_NOEXCEPT
-    {
-      minMaxTransformHierarchyDepthInter = minMaxTransformHierarchyDepthInter_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setMaxMaxTransformHierarchyDepthInter( uint8_t maxMaxTransformHierarchyDepthInter_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxMaxTransformHierarchyDepthInter = maxMaxTransformHierarchyDepthInter_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setMinMaxTransformHierarchyDepthIntra( uint8_t minMaxTransformHierarchyDepthIntra_ ) VULKAN_HPP_NOEXCEPT
-    {
-      minMaxTransformHierarchyDepthIntra = minMaxTransformHierarchyDepthIntra_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT &
-                            setMaxMaxTransformHierarchyDepthIntra( uint8_t maxMaxTransformHierarchyDepthIntra_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxMaxTransformHierarchyDepthIntra = maxMaxTransformHierarchyDepthIntra_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setMaxDiffCuQpDeltaDepth( uint8_t maxDiffCuQpDeltaDepth_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxDiffCuQpDeltaDepth = maxDiffCuQpDeltaDepth_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setMinMaxNumMergeCand( uint8_t minMaxNumMergeCand_ ) VULKAN_HPP_NOEXCEPT
-    {
-      minMaxNumMergeCand = minMaxNumMergeCand_;
-      return *this;
-    }
-
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265CapabilitiesEXT & setMaxMaxNumMergeCand( uint8_t maxMaxNumMergeCand_ ) VULKAN_HPP_NOEXCEPT
-    {
-      maxMaxNumMergeCand = maxMaxNumMergeCand_;
-      return *this;
-    }
-#  endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
-
     explicit operator VkVideoEncodeH265CapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT *>( this );
@@ -92925,7 +92762,7 @@ namespace VULKAN_HPP_NAMESPACE
     auto
 #    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
-               const void * const &,
+               void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT const &,
@@ -93006,7 +92843,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType                             sType                                  = StructureType::eVideoEncodeH265CapabilitiesEXT;
-    const void *                                                    pNext                                  = {};
+    void *                                                          pNext                                  = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT         flags                                  = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeH265InputModeFlagsEXT          inputModeFlags                         = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeH265OutputModeFlagsEXT         outputModeFlags                        = {};
@@ -94841,7 +94678,6 @@ namespace VULKAN_HPP_NAMESPACE
 #  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
     VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR           flags_                           = {},
                                              uint32_t                                            qualityLevel_                    = {},
-                                             VULKAN_HPP_NAMESPACE::Extent2D                      codedExtent_                     = {},
                                              VULKAN_HPP_NAMESPACE::Buffer                        dstBitstreamBuffer_              = {},
                                              VULKAN_HPP_NAMESPACE::DeviceSize                    dstBitstreamBufferOffset_        = {},
                                              VULKAN_HPP_NAMESPACE::DeviceSize                    dstBitstreamBufferMaxRange_      = {},
@@ -94854,7 +94690,6 @@ namespace VULKAN_HPP_NAMESPACE
       : pNext( pNext_ )
       , flags( flags_ )
       , qualityLevel( qualityLevel_ )
-      , codedExtent( codedExtent_ )
       , dstBitstreamBuffer( dstBitstreamBuffer_ )
       , dstBitstreamBufferOffset( dstBitstreamBufferOffset_ )
       , dstBitstreamBufferMaxRange( dstBitstreamBufferMaxRange_ )
@@ -94873,7 +94708,6 @@ namespace VULKAN_HPP_NAMESPACE
 #    if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
     VideoEncodeInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR                                                                flags_,
                         uint32_t                                                                                                 qualityLevel_,
-                        VULKAN_HPP_NAMESPACE::Extent2D                                                                           codedExtent_,
                         VULKAN_HPP_NAMESPACE::Buffer                                                                             dstBitstreamBuffer_,
                         VULKAN_HPP_NAMESPACE::DeviceSize                                                                         dstBitstreamBufferOffset_,
                         VULKAN_HPP_NAMESPACE::DeviceSize                                                                         dstBitstreamBufferMaxRange_,
@@ -94885,7 +94719,6 @@ namespace VULKAN_HPP_NAMESPACE
       : pNext( pNext_ )
       , flags( flags_ )
       , qualityLevel( qualityLevel_ )
-      , codedExtent( codedExtent_ )
       , dstBitstreamBuffer( dstBitstreamBuffer_ )
       , dstBitstreamBufferOffset( dstBitstreamBufferOffset_ )
       , dstBitstreamBufferMaxRange( dstBitstreamBufferMaxRange_ )
@@ -94926,12 +94759,6 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setCodedExtent( VULKAN_HPP_NAMESPACE::Extent2D const & codedExtent_ ) VULKAN_HPP_NOEXCEPT
-    {
-      codedExtent = codedExtent_;
-      return *this;
-    }
-
     VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBitstreamBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBitstreamBuffer_ ) VULKAN_HPP_NOEXCEPT
     {
       dstBitstreamBuffer = dstBitstreamBuffer_;
@@ -95012,7 +94839,6 @@ namespace VULKAN_HPP_NAMESPACE
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR const &,
                uint32_t const &,
-               VULKAN_HPP_NAMESPACE::Extent2D const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
@@ -95028,7 +94854,6 @@ namespace VULKAN_HPP_NAMESPACE
                        pNext,
                        flags,
                        qualityLevel,
-                       codedExtent,
                        dstBitstreamBuffer,
                        dstBitstreamBufferOffset,
                        dstBitstreamBufferMaxRange,
@@ -95049,11 +94874,10 @@ namespace VULKAN_HPP_NAMESPACE
       return this->reflect() == rhs.reflect();
 #    else
       return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( qualityLevel == rhs.qualityLevel ) &&
-             ( codedExtent == rhs.codedExtent ) && ( dstBitstreamBuffer == rhs.dstBitstreamBuffer ) &&
+             ( dstBitstreamBuffer == rhs.dstBitstreamBuffer ) && ( dstBitstreamBufferOffset == rhs.dstBitstreamBufferOffset ) &&
-             ( dstBitstreamBufferOffset == rhs.dstBitstreamBufferOffset ) && ( dstBitstreamBufferMaxRange == rhs.dstBitstreamBufferMaxRange ) &&
+             ( dstBitstreamBufferMaxRange == rhs.dstBitstreamBufferMaxRange ) && ( srcPictureResource == rhs.srcPictureResource ) &&
-             ( srcPictureResource == rhs.srcPictureResource ) && ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) &&
+             ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) &&
-             ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ) &&
+             ( pReferenceSlots == rhs.pReferenceSlots ) && ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes );
-             ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes );
 #    endif
     }
 
@@ -95068,7 +94892,6 @@ namespace VULKAN_HPP_NAMESPACE
     const void *                                        pNext                           = {};
     VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR           flags                           = {};
     uint32_t                                            qualityLevel                    = {};
-    VULKAN_HPP_NAMESPACE::Extent2D                      codedExtent                     = {};
     VULKAN_HPP_NAMESPACE::Buffer                        dstBitstreamBuffer              = {};
     VULKAN_HPP_NAMESPACE::DeviceSize                    dstBitstreamBufferOffset        = {};
     VULKAN_HPP_NAMESPACE::DeviceSize                    dstBitstreamBufferMaxRange      = {};

registry/vk.xml

@@ -159,7 +159,7 @@ branch of the member gitlab server.
         <type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.3 version number
 #define <name>VK_API_VERSION_1_3</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 3, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 210</type>
+#define <name>VK_HEADER_VERSION</name> 211</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, 3, VK_HEADER_VERSION)</type>
 
@@ -5608,6 +5608,12 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkDeviceSize</type>                       <name>updateScratchSize</name></member>
             <member><type>VkDeviceSize</type>                       <name>buildScratchSize</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceImage2DViewOf3DFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true" noautovalidity="true"><type>void</type>*                     <name>pNext</name></member>
+            <member><type>VkBool32</type>                                        <name>image2DViewOf3D</name></member>
+            <member><type>VkBool32</type>                                        <name>sampler2DViewOf3D</name></member>
+        </type>
         <type category="struct" name="VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
             <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"><type>VkStructureType</type> <name>sType</name></member>
             <member optional="true" noautovalidity="true"><type>void</type>*                     <name>pNext</name></member>
@@ -5857,8 +5863,6 @@ typedef void <name>CAMetalLayer</name>;
             <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR"><type>VkStructureType</type><name>sType</name></member>
             <member optional="true">const <type>void</type>*                            <name>pNext</name></member>
             <member optional="true"><type>VkVideoDecodeFlagsKHR</type>  <name>flags</name></member>
-            <member><type>VkOffset2D</type>                             <name>codedOffset</name></member>
-            <member><type>VkExtent2D</type>                             <name>codedExtent</name></member>
             <member><type>VkBuffer</type>                               <name>srcBuffer</name></member>
             <member><type>VkDeviceSize</type>                           <name>srcBufferOffset</name></member>
             <member><type>VkDeviceSize</type>                           <name>srcBufferRange</name></member>
@@ -5903,8 +5907,8 @@ typedef void <name>CAMetalLayer</name>;
         </type>
         <type category="struct" name="VkVideoDecodeH264CapabilitiesEXT" returnedonly="true" structextends="VkVideoDecodeCapabilitiesKHR">
             <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
-            <member optional="true"><type>void</type>*                            <name>pNext</name></member>
+            <member optional="true"><type>void</type>*            <name>pNext</name></member>
-            <member><type>uint32_t</type>                         <name>maxLevel</name></member>
+            <member><type>StdVideoH264Level</type>                <name>maxLevel</name></member>
             <member><type>VkOffset2D</type>                       <name>fieldOffsetGranularity</name></member>
         </type>
         <type requires="vk_video/vulkan_video_codec_h264std.h" name="StdVideoH264SequenceParameterSet"/>
@@ -5973,7 +5977,7 @@ typedef void <name>CAMetalLayer</name>;
         <type category="struct" name="VkVideoDecodeH265CapabilitiesEXT" returnedonly="true" structextends="VkVideoDecodeCapabilitiesKHR">
             <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
             <member optional="true"><type>void</type>*                            <name>pNext</name></member>
-            <member><type>uint32_t</type>                         <name>maxLevel</name></member>
+            <member><type>StdVideoH265Level</type>                                <name>maxLevel</name></member>
         </type>
         <type category="struct" name="VkVideoDecodeH265SessionParametersAddInfoEXT" structextends="VkVideoSessionParametersUpdateInfoKHR">
             <member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"><type>VkStructureType</type><name>sType</name></member>
@@ -6054,7 +6058,6 @@ typedef void <name>CAMetalLayer</name>;
             <member optional="true">const <type>void</type>*            <name>pNext</name></member>
             <member optional="true"><type>VkVideoEncodeFlagsKHR</type>  <name>flags</name></member>
             <member><type>uint32_t</type>                               <name>qualityLevel</name></member>
-            <member><type>VkExtent2D</type>                             <name>codedExtent</name></member>
             <member><type>VkBuffer</type>                               <name>dstBitstreamBuffer</name></member>
             <member><type>VkDeviceSize</type>                           <name>dstBitstreamBufferOffset</name></member>
             <member><type>VkDeviceSize</type>                           <name>dstBitstreamBufferMaxRange</name></member>
@@ -6082,18 +6085,18 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>uint32_t</type>                                 <name>virtualBufferSizeInMs</name></member>
             <member><type>uint32_t</type>                                 <name>initialVirtualBufferSizeInMs</name></member>
         </type>
-        <type category="struct" name="VkVideoEncodeCapabilitiesKHR" structextends="VkVideoCapabilitiesKHR">
+        <type category="struct" name="VkVideoEncodeCapabilitiesKHR" returnedonly="true" structextends="VkVideoCapabilitiesKHR">
             <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR"><type>VkStructureType</type><name>sType</name></member>
-            <member optional="true">const <type>void</type>*                           <name>pNext</name></member>
+            <member optional="true"><type>void</type>*                 <name>pNext</name></member>
             <member noautovalidity="true"><type>VkVideoEncodeCapabilityFlagsKHR</type>       <name>flags</name></member>
             <member><type>VkVideoEncodeRateControlModeFlagsKHR</type>  <name>rateControlModes</name></member>
             <member><type>uint8_t</type>                               <name>rateControlLayerCount</name></member>
             <member><type>uint8_t</type>                               <name>qualityLevelCount</name></member>
             <member><type>VkExtent2D</type>                            <name>inputImageDataFillAlignment</name></member>
         </type>
-        <type category="struct" name="VkVideoEncodeH264CapabilitiesEXT" structextends="VkVideoEncodeCapabilitiesKHR">
+        <type category="struct" name="VkVideoEncodeH264CapabilitiesEXT" returnedonly="true" structextends="VkVideoEncodeCapabilitiesKHR">
             <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
-            <member optional="true">const <type>void</type>*                           <name>pNext</name></member>
+            <member optional="true"><type>void</type>*                 <name>pNext</name></member>
             <member noautovalidity="true"><type>VkVideoEncodeH264CapabilityFlagsEXT</type>   <name>flags</name></member>
             <member><type>VkVideoEncodeH264InputModeFlagsEXT</type>    <name>inputModeFlags</name></member>
             <member><type>VkVideoEncodeH264OutputModeFlagsEXT</type>   <name>outputModeFlags</name></member>
@@ -6207,9 +6210,9 @@ typedef void <name>CAMetalLayer</name>;
             <member><type>VkBool32</type>                                        <name>useMaxFrameSize</name></member>
             <member><type>VkVideoEncodeH264FrameSizeEXT</type>                   <name>maxFrameSize</name></member>
         </type>
-        <type category="struct" name="VkVideoEncodeH265CapabilitiesEXT" structextends="VkVideoEncodeCapabilitiesKHR">
+        <type category="struct" name="VkVideoEncodeH265CapabilitiesEXT" returnedonly="true" structextends="VkVideoEncodeCapabilitiesKHR">
             <member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
-            <member optional="true">const <type>void</type>*           <name>pNext</name></member>
+            <member optional="true"><type>void</type>*                 <name>pNext</name></member>
             <member noautovalidity="true"><type>VkVideoEncodeH265CapabilityFlagsEXT</type>   <name>flags</name></member>
             <member><type>VkVideoEncodeH265InputModeFlagsEXT</type>    <name>inputModeFlags</name></member>
             <member><type>VkVideoEncodeH265OutputModeFlagsEXT</type>   <name>outputModeFlags</name></member>
@@ -8283,7 +8286,7 @@ typedef void <name>CAMetalLayer</name>;
         <enum bitpos="12"   name="VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT"/>
         <enum               name="VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR" alias="VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT"/>
         <enum               name="VK_PIPELINE_STAGE_2_TRANSFER_BIT" alias="VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR"/>
-        <enum               name="VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR" alias="VK_PIPELINE_STAGE_2_TRANSFER_BIT"/>
+        <enum               name="VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR" alias="VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT"/>
         <enum bitpos="13"   name="VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT"/>
         <enum               name="VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR" alias="VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT"/>
         <enum bitpos="14"   name="VK_PIPELINE_STAGE_2_HOST_BIT"/>
@@ -8529,20 +8532,22 @@ typedef void <name>CAMetalLayer</name>;
         <enum bitpos="7"      name="VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT"/>
         <enum bitpos="8"      name="VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT"/>
         <enum bitpos="9"      name="VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT"/>
-        <enum bitpos="10"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT"/>
+        <enum bitpos="10"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT"/>
-        <enum bitpos="11"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT"/>
+        <enum bitpos="11"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT"/>
-        <enum bitpos="12"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT"/>
+        <enum bitpos="12"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT"/>
-        <enum bitpos="13"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT"/>
+        <enum bitpos="13"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT"/>
-        <enum bitpos="14"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT"/>
+        <enum bitpos="14"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT"/>
-        <enum bitpos="15"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT"/>
+        <enum bitpos="15"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT"/>
-        <enum bitpos="16"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT"/>
+        <enum bitpos="16"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT"/>
-        <enum bitpos="17"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT"/>
+        <enum bitpos="17"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT"/>
-        <enum bitpos="18"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT"/>
+        <enum bitpos="18"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT"/>
-        <enum bitpos="19"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT"/>
+        <enum bitpos="19"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT"/>
-        <enum bitpos="20"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT"/>
+        <enum bitpos="20"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT"/>
-        <enum bitpos="21"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT"/>
+        <enum bitpos="21"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT"/>
-        <enum bitpos="22"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT"/>
+        <enum bitpos="22"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT"/>
-        <enum bitpos="23"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT"/>
+        <enum bitpos="23"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT"/>
+        <enum bitpos="24"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT"/>
+        <enum bitpos="25"     name="VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT"/>
     </enums>
     <enums name="VkVideoEncodeH265InputModeFlagBitsEXT" type="bitmask">
         <enum bitpos="0"      name="VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT"/>
@@ -11679,7 +11684,7 @@ typedef void <name>CAMetalLayer</name>;
             <param><type>uint32_t</type> <name>connectorId</name></param>
             <param><type>VkDisplayKHR</type>* <name>display</name></param>
         </command>
-        <command successcodes="VK_SUCCESS,VK_TIMEOUT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
+        <command successcodes="VK_SUCCESS,VK_TIMEOUT,VK_SUBOPTIMAL_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT">
             <proto><type>VkResult</type> <name>vkWaitForPresentKHR</name></proto>
             <param><type>VkDevice</type> <name>device</name></param>
             <param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
@@ -13427,7 +13432,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_KHR_video_decode_queue" number="25" type="device" requires="VK_KHR_video_queue,VK_KHR_synchronization2" author="KHR" contact="jake.beju@amd.com" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="3"                                         name="VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION"/>
+                <enum value="4"                                         name="VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION"/>
                 <enum value="&quot;VK_KHR_video_decode_queue&quot;"     name="VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
@@ -13639,7 +13644,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_video_encode_h265" number="40" type="device" requires="VK_KHR_video_encode_queue" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="6"                                              name="VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION"/>
+                <enum value="7"                                              name="VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_video_encode_h265&quot;"           name="VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="1" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
@@ -13684,7 +13689,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_video_decode_h264" number="41" type="device" requires="VK_KHR_video_decode_queue" author="KHR" contact="peter.fang@amd.com" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="4"                                              name="VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION"/>
+                <enum value="5"                                              name="VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_video_decode_h264&quot;"           name="VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="1" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
@@ -15800,7 +15805,7 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_EXT_video_decode_h265" number="188" type="device" requires="VK_KHR_video_decode_queue" author="KHR" contact="peter.fang@amd.com" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="2"                                         name="VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION"/>
+                <enum value="3"                                         name="VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_video_decode_h265&quot;"      name="VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
                 <enum offset="1" extends="VkStructureType"              name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
@@ -17077,7 +17082,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="Ahmed Abdelkhalek @aabdelkh" provisional="true" platform="provisional" supported="vulkan">
             <require>
-                <enum value="4"                                         name="VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION"/>
+                <enum value="5"                                         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="VkPipelineStageFlagBits2"    name="VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS" />
                 <enum bitpos="37" extends="VkAccessFlagBits2"           name="VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR" protect="VK_ENABLE_BETA_EXTENSIONS" />
@@ -18052,11 +18057,13 @@ typedef void <name>CAMetalLayer</name>;
                 <type name="VkMultiDrawIndexedInfoEXT"/>
             </require>
         </extension>
-        <extension name="VK_EXT_extension_394" number="394" author="EXT" contact="Mike Blumenkrantz @zmike" type="device" supported="disabled">
+        <extension name="VK_EXT_image_2d_view_of_3d" number="394" requires="VK_KHR_maintenance1,VK_KHR_get_physical_device_properties2" author="EXT" contact="Mike Blumenkrantz @zmike" specialuse="glemulation" type="device" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_EXT_EXTENSION_394_SPEC_VERSION"/>
+                <enum value="1"                                             name="VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION"/>
-                <enum value="&quot;VK_EXT_extension_394&quot;"              name="VK_EXT_EXTENSION_394_EXTENSION_NAME"/>
+                <enum value="&quot;VK_EXT_image_2d_view_of_3d&quot;"              name="VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME"/>
-                <enum extends="VkImageCreateFlagBits" bitpos="17" name="VK_IMAGE_CREATE_RESERVED_394_BIT_EXT"/>
+                <enum offset="0" extends="VkStructureType"             name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT"/>
+                <type name="VkPhysicalDeviceImage2DViewOf3DFeaturesEXT"/>
+                <enum extends="VkImageCreateFlagBits" bitpos="17"  name="VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT" comment="Image is created with a layout where individual slices are capable of being used as 2D images"/>
             </require>
         </extension>
         <extension name="VK_KHR_portability_enumeration" number="395" author="KHR" contact="Charles Giessen @charles-lunarg" type="instance" supported="vulkan">
@@ -18074,8 +18081,18 @@ typedef void <name>CAMetalLayer</name>;
         </extension>
         <extension name="VK_NV_extension_397" number="397" author="NV" contact="Christoph Kubisch @pixeljetstream" supported="disabled">
             <require>
-                <enum value="0"                                         name="VK_NV_EXTENSION_397_SPEC_VERSION"/>
+                <enum value="0"                                                     name="VK_NV_EXTENSION_397_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_397&quot;"           name="VK_NV_EXTENSION_397_EXTENSION_NAME"/>
+                <enum value="&quot;VK_NV_extension_397&quot;"                       name="VK_NV_EXTENSION_397_EXTENSION_NAME"/>
+                <enum bitpos="30" extends="VkPipelineStageFlagBits2"                name="VK_PIPELINE_STAGE_2_RESERVED_30_BIT_NV"/>
+                <enum bitpos="44" extends="VkAccessFlagBits2"                       name="VK_ACCESS_2_RESERVED_44_BIT_NV"/>
+                <enum bitpos="45" extends="VkAccessFlagBits2"                       name="VK_ACCESS_2_RESERVED_45_BIT_NV"/>
+                <enum bitpos="23" extends="VkBufferUsageFlagBits"                   name="VK_BUFFER_USAGE_RESERVED_23_BIT_NV"/>
+                <enum bitpos="24" extends="VkBufferUsageFlagBits"                   name="VK_BUFFER_USAGE_RESERVED_24_BIT_NV"/>
+                <enum bitpos="24" extends="VkPipelineCreateFlagBits"                name="VK_PIPELINE_CREATE_RESERVED_24_BIT_NV"/>
+                <enum bitpos="4"  extends="VkGeometryInstanceFlagBitsKHR"           name="VK_GEOMETRY_INSTANCE_RESERVED_4_BIT_NV"/>
+                <enum bitpos="5"  extends="VkGeometryInstanceFlagBitsKHR"           name="VK_GEOMETRY_INSTANCE_RESERVED_5_BIT_NV"/>
+                <enum bitpos="6"  extends="VkBuildAccelerationStructureFlagBitsKHR" name="VK_BUILD_ACCELERATION_STRUCTURE_RESERVED_6_BIT_NV"/>
+                <enum bitpos="7"  extends="VkBuildAccelerationStructureFlagBitsKHR" name="VK_BUILD_ACCELERATION_STRUCTURE_RESERVED_7_BIT_NV"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_398" number="398" author="NV" contact="Christoph Kubisch @pixeljetstream" supported="disabled">
@@ -18527,6 +18544,12 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_EXT_extension_463&quot;"          name="VK_EXT_EXTENSION_463_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_EXT_extension_464" number="464" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_EXT_EXTENSION_464_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_464&quot;"          name="VK_EXT_EXTENSION_464_EXTENSION_NAME"/>
+            </require>
+        </extension>
         <extension name="VK_NV_extension_465" number="465" author="NV" contact="Carsten Rohde @crohde" supported="disabled">
             <require>
                 <enum value="0"                                             name="VK_NV_EXTENSION_465_SPEC_VERSION"/>
@@ -18541,10 +18564,24 @@ typedef void <name>CAMetalLayer</name>;
                 <enum bitpos="43" extends="VkFormatFeatureFlagBits2"        name="VK_FORMAT_FEATURE_2_RESERVED_43_BIT_NV"/>
             </require>
         </extension>
-        <extension name="VK_EXT_extension_464" number="464" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
+        <extension name="VK_EXT_extension_466" number="466" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
             <require>
-                <enum value="0"                                         name="VK_EXT_EXTENSION_464_SPEC_VERSION"/>
+                <enum value="0"                                         name="VK_EXT_EXTENSION_466_SPEC_VERSION"/>
-                <enum value="&quot;VK_EXT_extension_464&quot;"          name="VK_EXT_EXTENSION_464_EXTENSION_NAME"/>
+                <enum value="&quot;VK_EXT_extension_466&quot;"          name="VK_EXT_EXTENSION_466_EXTENSION_NAME"/>
+                <enum bitpos="7" extends="VkSubpassDescriptionFlagBits" name="VK_SUBPASS_DESCRIPTION_RESERVED_7_BIT_EXT"/>
+                <enum bitpos="3" extends="VkRenderingFlagBits"          name="VK_RENDERING_RESERVED_3_BIT_EXT"/>
+            </require>
+        </extension>
+        <extension name="VK_EXT_extension_467" number="467" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_EXT_EXTENSION_467_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_467&quot;"          name="VK_EXT_EXTENSION_467_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_EXT_extension_468" number="468" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_EXT_EXTENSION_468_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_extension_468&quot;"          name="VK_EXT_EXTENSION_468_EXTENSION_NAME"/>
             </require>
         </extension>
     </extensions>

registry/vkconventions.py

@@ -22,6 +22,8 @@ CATEGORIES_REQUIRING_VALIDATION = set(('handle', 'enum', 'bitmask'))
 # Ideally these would be listed in the spec as exceptions, as OpenXR does.
 SPECIAL_WORDS = set((
     '16Bit',  # VkPhysicalDevice16BitStorageFeatures
+    '2D',     # VkPhysicalDeviceImage2DViewOf3DFeaturesEXT
+    '3D',     # VkPhysicalDeviceImage2DViewOf3DFeaturesEXT
     '8Bit',  # VkPhysicalDevice8BitStorageFeaturesKHR
     'AABB',  # VkGeometryAABBNV
     'ASTC',  # VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT