[BOT] update dependencies

third_party/vulkan/vulkan.cppm

@@ -24,9 +24,9 @@ VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING )
 
 export module vulkan;
 
-export import std;
+import std;
 
-VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 359, "Wrong VK_HEADER_VERSION!" );
+VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 361, "Wrong VK_HEADER_VERSION!" );
 
 #if defined( __clang__ )
 #  pragma clang diagnostic push

third_party/vulkan/vulkan.hpp

@@ -18,6 +18,9 @@
 #  include <string.h>  // strnlen
 #  include <string>    // std::string
 #  include <utility>   // std::exchange
+#  if defined( __APPLE__ )
+#    include <cstdlib>  // std::getenv
+#  endif
 #  if 17 <= VULKAN_HPP_CPP_VERSION
 #    include <string_view>
 #  endif
@@ -36,7 +39,7 @@
 #  endif
 #endif
 
-VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 359, "Wrong VK_HEADER_VERSION!" );
+VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 361, "Wrong VK_HEADER_VERSION!" );
 
 VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
 {
@@ -87,14 +90,24 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
 
     VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) {}
 
+#if VULKAN_HPP_CPP_VERSION < 20
     template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+#else
+    template <typename B = T>
+    requires std::is_same<B, char>::value
+#endif
     VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string const & data ) VULKAN_HPP_NOEXCEPT
     {
       copy( data.data(), data.length() );
     }
 
 #if 17 <= VULKAN_HPP_CPP_VERSION
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+#  else
+    template <typename B = T>
+    requires std::is_same<B, char>::value
+#  endif
     VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string_view data ) VULKAN_HPP_NOEXCEPT
     {
       copy( data.data(), data.length() );
@@ -124,14 +137,24 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       return this->data();
     }
 
+#if VULKAN_HPP_CPP_VERSION < 20
     template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+#else
+    template <typename B = T>
+    requires std::is_same<B, char>::value
+#endif
     operator std::string() const
     {
       return std::string( this->data(), strnlen( this->data(), N ) );
     }
 
 #if 17 <= VULKAN_HPP_CPP_VERSION
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+#  else
+    template <typename B = T>
+    requires std::is_same<B, char>::value
+#  endif
     operator std::string_view() const
     {
       return std::string_view( this->data(), strnlen( this->data(), N ) );
@@ -344,7 +367,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     {
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+#  else
+    template <typename B = T>
+    requires std::is_const<B>::value
+#  endif
     ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
       : m_count( static_cast<uint32_t>( list.size() ) )
       , m_ptr( list.begin() )
@@ -357,9 +385,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
 
     // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
     // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename V,
               typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
                                       std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
+#  else
+    template <typename V>
+    requires std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
+               std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value
+#  endif
     ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT
       : m_count( static_cast<uint32_t>( v.size() ) )
       , m_ptr( v.data() )
@@ -424,8 +458,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     {
     }
 
-    template <typename B = T, typename std::enable_if<std::is_convertible<B, T>::value && std::is_lvalue_reference<B>::value, int>::type = 0>
+#  if VULKAN_HPP_CPP_VERSION < 20
-    ArrayProxyNoTemporaries( B && value ) VULKAN_HPP_NOEXCEPT
+    template <typename S, typename std::enable_if<std::is_convertible<S, T>::value && std::is_lvalue_reference<S>::value, int>::type = 0>
+#  else
+    template <typename S>
+    requires std::is_convertible<S, T>::value && std::is_lvalue_reference<S>::value
+#  endif
+    ArrayProxyNoTemporaries( S && value ) VULKAN_HPP_NOEXCEPT
       : m_count( 1 )
       , m_ptr( &value )
     {
@@ -448,11 +487,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     ArrayProxyNoTemporaries( T ( &&ptr )[C] ) = delete;
 
     // Any l-value reference with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename V,
               typename std::enable_if<!std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
                                         std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
                                         std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value,
                                       int>::type = 0>
+#  else
+    template <typename V>
+    requires( !std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
+              std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
+              std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value )
+#  endif
     ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
       : m_count( static_cast<uint32_t>( v.size() ) )
       , m_ptr( v.data() )
@@ -460,10 +506,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     }
 
     // Any l-value reference with a .begin() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename V,
               typename std::enable_if<std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
                                         std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value,
                                       int>::type = 0>
+#  else
+    template <typename V>
+    requires std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
+               std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value
+#  endif
     ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
       : m_count( static_cast<uint32_t>( v.size() ) )
       , m_ptr( v.begin() )
@@ -605,16 +657,28 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  template <typename Type, class...>
+  struct IsFirstInStructureChain
+  {
+    static bool const value = false;
+  };
+
+  template <typename Type, typename Head, typename... Tail>
+  struct IsFirstInStructureChain<Type, Head, Tail...>
+  {
+    static bool const value = std::is_same<Type, Head>::value;
+  };
+
   template <typename Type, class...>
   struct IsPartOfStructureChain
   {
-    static bool const valid = false;
+    static bool const value = false;
   };
 
   template <typename Type, typename Head, typename... Tail>
   struct IsPartOfStructureChain<Type, Head, Tail...>
   {
-    static bool const valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
+    static bool const value = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::value;
   };
 
   template <size_t Index, typename T, typename... ChainElements>
@@ -772,28 +836,46 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
+    template <typename ClassType,
+              size_t Which                                                                                                      = 0,
+              typename std::enable_if<IsFirstInStructureChain<ClassType, ChainElements...>::value && ( Which == 0 ), int>::type = 0>
+#  else
     template <typename ClassType, size_t Which = 0>
-    VULKAN_HPP_NODISCARD
+    requires IsFirstInStructureChain<ClassType, ChainElements...>::value && ( Which == 0 )
-      typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && ( Which == 0 ), bool>::type
+#  endif
-      isLinked() const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_NODISCARD bool isLinked() const VULKAN_HPP_NOEXCEPT
     {
       return true;
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
+    template <typename ClassType,
+              size_t Which                       = 0,
+              typename std::enable_if<( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) &&
+                                        IsPartOfStructureChain<ClassType, ChainElements...>::value,
+                                      int>::type = 0>
+#  else
     template <typename ClassType, size_t Which = 0>
-    VULKAN_HPP_NODISCARD
+    requires( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) && IsPartOfStructureChain<ClassType, ChainElements...>::value
-      typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), bool>::type
+#  endif
-      isLinked() const VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_NODISCARD bool isLinked() const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
       return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
+    template <typename ClassType,
+              size_t Which                       = 0,
+              typename std::enable_if<( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) &&
+                                        IsPartOfStructureChain<ClassType, ChainElements...>::value,
+                                      int>::type = 0>
+#  else
     template <typename ClassType, size_t Which = 0>
-    typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
+    requires( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) && IsPartOfStructureChain<ClassType, ChainElements...>::value
-      relink() VULKAN_HPP_NOEXCEPT
+#  endif
+    void relink() VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
       auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
       VULKAN_HPP_ASSERT( !isLinked( pNext ) );
       auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
@@ -801,11 +883,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       headElement.pNext  = pNext;
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
+    template <typename ClassType,
+              size_t Which                       = 0,
+              typename std::enable_if<( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) &&
+                                        IsPartOfStructureChain<ClassType, ChainElements...>::value,
+                                      int>::type = 0>
+#  else
     template <typename ClassType, size_t Which = 0>
-    typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
+    requires( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) && IsPartOfStructureChain<ClassType, ChainElements...>::value
-      unlink() VULKAN_HPP_NOEXCEPT
+#  endif
+    void unlink() VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
       unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
     }
 
@@ -848,16 +937,26 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       return false;
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
+    template <size_t Index, typename std::enable_if<Index != 0, int>::type = 0>
+#  else
     template <size_t Index>
-    typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
+    requires( Index != 0 )
+#  endif
+    void link() VULKAN_HPP_NOEXCEPT
     {
       auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) );
       x.pNext  = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) );
       link<Index - 1>();
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
+    template <size_t Index, typename std::enable_if<Index == 0, int>::type = 0>
+#  else
     template <size_t Index>
-    typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
+    requires( Index == 0 )
+#  endif
+    void link() VULKAN_HPP_NOEXCEPT
     {
     }
 
@@ -9338,47 +9437,83 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
   //=========================
   //=== CONSTEXPR CALLEEs ===
   //=========================
+#if VULKAN_HPP_CPP_VERSION < 20
   template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+#else
+  template <std::integral T>
+#endif
   VULKAN_HPP_CONSTEXPR uint32_t apiVersionMajor( T const version )
   {
     return ( ( (uint32_t)( version ) >> 22U ) & 0x7FU );
   }
+#if VULKAN_HPP_CPP_VERSION < 20
   template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+#else
+  template <std::integral T>
+#endif
   VULKAN_HPP_CONSTEXPR uint32_t apiVersionMinor( T const version )
   {
     return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
   }
+#if VULKAN_HPP_CPP_VERSION < 20
   template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+#else
+  template <std::integral T>
+#endif
   VULKAN_HPP_CONSTEXPR uint32_t apiVersionPatch( T const version )
   {
     return ( (uint32_t)( version ) & 0xFFFU );
   }
+#if VULKAN_HPP_CPP_VERSION < 20
   template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+#else
+  template <std::integral T>
+#endif
   VULKAN_HPP_CONSTEXPR uint32_t apiVersionVariant( T const version )
   {
     return ( (uint32_t)( version ) >> 29U );
   }
+#if VULKAN_HPP_CPP_VERSION < 20
   template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+#else
+  template <std::integral T>
+#endif
   VULKAN_HPP_CONSTEXPR uint32_t makeApiVersion( T const variant, T const major, T const minor, T const patch )
   {
     return ( ( ( (uint32_t)( variant ) ) << 29U ) | ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
   }
+#if VULKAN_HPP_CPP_VERSION < 20
   template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+#else
+  template <std::integral T>
+#endif
   VULKAN_HPP_CONSTEXPR uint32_t makeVersion( T const major, T const minor, T const patch )
   {
     return ( ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
   }
+#if VULKAN_HPP_CPP_VERSION < 20
   template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+#else
+  template <std::integral T>
+#endif
   VULKAN_HPP_CONSTEXPR uint32_t versionMajor( T const version )
   {
     return ( (uint32_t)( version ) >> 22U );
   }
+#if VULKAN_HPP_CPP_VERSION < 20
   template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+#else
+  template <std::integral T>
+#endif
   VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version )
   {
     return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
   }
+#if VULKAN_HPP_CPP_VERSION < 20
   template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
+#else
+  template <std::integral T>
+#endif
   VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version )
   {
     return ( (uint32_t)( version ) & 0xFFFU );
@@ -11413,6 +11548,17 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixDecodeVectorSpecVersion   = VK_NV_COOPERATIVE_MATRIX_DECODE_VECTOR_SPEC_VERSION;
   VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixDecodeVectorExtensionName = VK_NV_COOPERATIVE_MATRIX_DECODE_VECTOR_EXTENSION_NAME;
 
+  //=== VK_NV_private_data_base_handle ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVPrivateDataBaseHandleSpecVersion   = VK_NV_PRIVATE_DATA_BASE_HANDLE_SPEC_VERSION;
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVPrivateDataBaseHandleExtensionName = VK_NV_PRIVATE_DATA_BASE_HANDLE_EXTENSION_NAME;
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <typename Allocator, typename T>
+  concept IsAllocator = requires( Allocator allocator, std::size_t n ) {
+                          { *allocator.allocate( n ) } -> std::same_as<typename Allocator::value_type &>;
+                          { allocator.deallocate( allocator.allocate( n ), n ) };
+                        } && std::copy_constructible<Allocator> && std::equality_comparable<Allocator> && std::same_as<typename Allocator ::value_type, T>;
+#endif
 }  // namespace VULKAN_HPP_NAMESPACE
 
 // clang-format off
@@ -23050,6 +23196,25 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_NV_private_data_base_handle ===
+  template <>
+  struct StructExtends<PhysicalDevicePrivateDataBaseHandleFeaturesNV, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDevicePrivateDataBaseHandleFeaturesNV, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
 #endif  // VULKAN_HPP_DISABLE_ENHANCED_MODE
 
   namespace detail

third_party/vulkan/vulkan_core.h

@@ -66,7 +66,7 @@ extern "C" {
 //#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 359
+#define VK_HEADER_VERSION 361
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@@ -1493,6 +1493,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT = 1000687000,
     VK_STRUCTURE_TYPE_IMAGE_TILING_CONTROL_CREATE_INFO_EXT = 1000687001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV = 1000689000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_BASE_HANDLE_FEATURES_NV = 1000707000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
   // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a legacy alias
@@ -7127,6 +7128,11 @@ typedef enum VkToolPurposeFlagBits {
     VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkToolPurposeFlagBits;
 typedef VkFlags VkToolPurposeFlags;
+
+typedef enum VkPrivateDataSlotCreateFlagBits {
+    VK_PRIVATE_DATA_SLOT_CREATE_BASE_OBJECT_HANDLE_BIT_NV = 0x00000001,
+    VK_PRIVATE_DATA_SLOT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPrivateDataSlotCreateFlagBits;
 typedef VkFlags VkPrivateDataSlotCreateFlags;
 typedef VkFlags64 VkPipelineStageFlags2;
 
@@ -20070,6 +20076,8 @@ typedef VkPrivateDataSlot VkPrivateDataSlotEXT;
 #define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data"
 typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT;
 
+typedef VkPrivateDataSlotCreateFlagBits VkPrivateDataSlotCreateFlagBitsEXT;
+
 typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT;
 
 typedef VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT;
@@ -24007,7 +24015,7 @@ typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
 
 // VK_NV_low_latency2 is a preprocessor guard. Do not pass it to API calls.
 #define VK_NV_low_latency2 1
-#define VK_NV_LOW_LATENCY_2_SPEC_VERSION  2
+#define VK_NV_LOW_LATENCY_2_SPEC_VERSION  3
 #define VK_NV_LOW_LATENCY_2_EXTENSION_NAME "VK_NV_low_latency2"
 
 typedef enum VkLatencyMarkerNV {
@@ -26588,6 +26596,18 @@ typedef struct VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV {
 
 
 
+// VK_NV_private_data_base_handle is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_private_data_base_handle 1
+#define VK_NV_PRIVATE_DATA_BASE_HANDLE_SPEC_VERSION 1
+#define VK_NV_PRIVATE_DATA_BASE_HANDLE_EXTENSION_NAME "VK_NV_private_data_base_handle"
+typedef struct VkPhysicalDevicePrivateDataBaseHandleFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           privateDataBaseHandle;
+} VkPhysicalDevicePrivateDataBaseHandleFeaturesNV;
+
+
+
 // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_acceleration_structure 1
 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13

third_party/vulkan/vulkan_enums.hpp

@@ -22,6 +22,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
   };
 
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <typename T>
+  concept Bitmask = FlagTraits<T>::isBitmask;
+#endif
+
   template <typename BitType>
   class Flags
   {
@@ -142,85 +147,101 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
 
 #if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
   // relational operators only needed for pre C++20
-  template <typename BitType>
+  template <typename T>
-  VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_CONSTEXPR bool operator<( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
   {
     return flags.operator>( bit );
   }
 
-  template <typename BitType>
+  template <typename T>
-  VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_CONSTEXPR bool operator<=( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
   {
     return flags.operator>=( bit );
   }
 
-  template <typename BitType>
+  template <typename T>
-  VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_CONSTEXPR bool operator>( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
   {
     return flags.operator<( bit );
   }
 
-  template <typename BitType>
+  template <typename T>
-  VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_CONSTEXPR bool operator>=( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
   {
     return flags.operator<=( bit );
   }
 
-  template <typename BitType>
+  template <typename T>
-  VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_CONSTEXPR bool operator==( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
   {
     return flags.operator==( bit );
   }
 
-  template <typename BitType>
+  template <typename T>
-  VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_CONSTEXPR bool operator!=( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
   {
     return flags.operator!=( bit );
   }
 #endif
 
   // bitwise operators
-  template <typename BitType>
+  template <typename T>
-  VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_CONSTEXPR Flags<T> operator&( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
   {
     return flags.operator&( bit );
   }
 
-  template <typename BitType>
+  template <typename T>
-  VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_CONSTEXPR Flags<T> operator|( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
   {
     return flags.operator|( bit );
   }
 
-  template <typename BitType>
+  template <typename T>
-  VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+  VULKAN_HPP_CONSTEXPR Flags<T> operator^( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
   {
     return flags.operator^( bit );
   }
 
-  // bitwise operators on BitType
+// bitwise operators on BitType T
-  template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+#if VULKAN_HPP_CPP_VERSION < 20
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+  template <typename T, typename std::enable_if<FlagTraits<T>::isBitmask, bool>::type = true>
+#else
+  template <Bitmask T>
+#endif
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<T> operator&( T lhs, T rhs ) VULKAN_HPP_NOEXCEPT
   {
-    return Flags<BitType>( lhs ) & rhs;
+    return Flags<T>( lhs ) & rhs;
   }
 
-  template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+#if VULKAN_HPP_CPP_VERSION < 20
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+  template <typename T, typename std::enable_if<FlagTraits<T>::isBitmask, bool>::type = true>
+#else
+  template <Bitmask T>
+#endif
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<T> operator|( T lhs, T rhs ) VULKAN_HPP_NOEXCEPT
   {
-    return Flags<BitType>( lhs ) | rhs;
+    return Flags<T>( lhs ) | rhs;
   }
 
-  template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+#if VULKAN_HPP_CPP_VERSION < 20
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
+  template <typename T, typename std::enable_if<FlagTraits<T>::isBitmask, bool>::type = true>
+#else
+  template <Bitmask T>
+#endif
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<T> operator^( T lhs, T rhs ) VULKAN_HPP_NOEXCEPT
   {
-    return Flags<BitType>( lhs ) ^ rhs;
+    return Flags<T>( lhs ) ^ rhs;
   }
 
-  template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
+#if VULKAN_HPP_CPP_VERSION < 20
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
+  template <typename T, typename std::enable_if<FlagTraits<T>::isBitmask, bool>::type = true>
+#else
+  template <Bitmask T>
+#endif
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<T> operator~( T bit ) VULKAN_HPP_NOEXCEPT
   {
-    return ~( Flags<BitType>( bit ) );
+    return ~( Flags<T>( bit ) );
   }
 
   //=============
@@ -1871,7 +1892,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     ePhysicalDevicePrimitiveRestartIndexFeaturesEXT                = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT,
     ePhysicalDeviceImageTilingControlFeaturesEXT                   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT,
     eImageTilingControlCreateInfoEXT                               = VK_STRUCTURE_TYPE_IMAGE_TILING_CONTROL_CREATE_INFO_EXT,
-    ePhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV
+    ePhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV,
+    ePhysicalDevicePrivateDataBaseHandleFeaturesNV                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_BASE_HANDLE_FEATURES_NV
   };
 
   // wrapper class for enum VkObjectType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkObjectType.html
@@ -5078,8 +5100,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       ToolPurposeFlagBits::eModifyingFeatures | ToolPurposeFlagBits::eDebugReportingEXT | ToolPurposeFlagBits::eDebugMarkersEXT;
   };
 
+  // wrapper class for enum VkPrivateDataSlotCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateFlagBits.html
   enum class PrivateDataSlotCreateFlagBits : VkPrivateDataSlotCreateFlags
   {
+    eBaseObjectHandleNV = VK_PRIVATE_DATA_SLOT_CREATE_BASE_OBJECT_HANDLE_BIT_NV
   };
 
   using PrivateDataSlotCreateFlagBitsEXT = PrivateDataSlotCreateFlagBits;
@@ -5091,8 +5115,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
   template <>
   struct FlagTraits<PrivateDataSlotCreateFlagBits>
   {
+    using WrappedType                                                         = VkPrivateDataSlotCreateFlagBits;
     static VULKAN_HPP_CONST_OR_CONSTEXPR bool                       isBitmask = true;
-    static VULKAN_HPP_CONST_OR_CONSTEXPR PrivateDataSlotCreateFlags allFlags  = {};
+    static VULKAN_HPP_CONST_OR_CONSTEXPR PrivateDataSlotCreateFlags allFlags  = PrivateDataSlotCreateFlagBits::eBaseObjectHandleNV;
   };
 
   // wrapper class for enum VkPipelineStageFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits2.html

third_party/vulkan/vulkan_extension_inspection.hpp

@@ -552,7 +552,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
                                                             "VK_ARM_data_graph_neural_accelerator_statistics",
                                                             "VK_EXT_primitive_restart_index",
                                                             "VK_EXT_image_tiling_control",
-                                                            "VK_NV_cooperative_matrix_decode_vector" };
+                                                            "VK_NV_cooperative_matrix_decode_vector",
+                                                            "VK_NV_private_data_base_handle" };
     return deviceExtensions;
   }
 
@@ -2450,6 +2451,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_EXT_image_compression_control",
+              "VK_KHR_swapchain",
             } } } } },
       { "VK_QCOM_image_processing",
         { { "VK_VERSION_1_0",
@@ -3292,17 +3294,35 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_shader_float16_int8",
             } } },
           { "VK_VERSION_1_2", { {} } } } },
+      { "VK_ARM_data_graph_neural_accelerator_statistics",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_primitive_restart_index",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_image_tiling_control",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_NV_cooperative_matrix_decode_vector",
         { { "VK_VERSION_1_0",
             { {
               "VK_NV_cooperative_matrix2",
-            } } } } }
+            } } } } },
+      { "VK_NV_private_data_base_handle",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_EXT_private_data",
+            } } },
+          { "VK_VERSION_1_3", { {} } } } }
     };
     auto depIt = dependencies.find( extension );
     return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
@@ -4292,7 +4312,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_EXT_shader_ocp_microscaling_types" ) || ( extension == "VK_VALVE_shader_mixed_float_dot_product" ) ||
            ( extension == "VK_SEC_throttle_hint" ) || ( extension == "VK_ARM_data_graph_neural_accelerator_statistics" ) ||
            ( extension == "VK_EXT_primitive_restart_index" ) || ( extension == "VK_EXT_image_tiling_control" ) ||
-           ( extension == "VK_NV_cooperative_matrix_decode_vector" );
+           ( extension == "VK_NV_cooperative_matrix_decode_vector" ) || ( extension == "VK_NV_private_data_base_handle" );
   }
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

third_party/vulkan/vulkan_hash.hpp

@@ -14423,6 +14423,20 @@ VULKAN_HPP_EXPORT namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV const & physicalDevicePrivateDataBaseHandleFeaturesNV ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataBaseHandleFeaturesNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataBaseHandleFeaturesNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataBaseHandleFeaturesNV.privateDataBaseHandle );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures>
   {

third_party/vulkan/vulkan_raii.hpp

@@ -3344,6 +3344,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
     };
 
+#  if 20 <= VULKAN_HPP_CPP_VERSION
+    template <typename T>
+    concept VulkanRAIIHandleType = isVulkanRAIIHandleType<T>::value;
+#  endif
+
     class Context
     {
     public:
@@ -15877,51 +15882,78 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     };
 
     // operators to compare VULKAN_HPP_NAMESPACE::raii-handles
-#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
+#  else
+    template <VulkanRAIIHandleType T>
+#  endif
+#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT
     {
       return *a <=> *b;
     }
 #  else
-    template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
     bool operator<( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT
     {
       return *a < *b;
     }
 #  endif
 
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
+#  else
+    template <VulkanRAIIHandleType T>
+#  endif
     bool operator==( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT
     {
       return *a == *b;
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
+#  else
+    template <VulkanRAIIHandleType T>
+#  endif
     bool operator!=( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT
     {
       return *a != *b;
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
+#  else
+    template <VulkanRAIIHandleType T>
+#  endif
     bool operator==( T const & v, std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
       return !*v;
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
+#  else
+    template <VulkanRAIIHandleType T>
+#  endif
     bool operator==( std::nullptr_t, T const & v ) VULKAN_HPP_NOEXCEPT
     {
       return !*v;
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
+#  else
+    template <VulkanRAIIHandleType T>
+#  endif
     bool operator!=( T const & v, std::nullptr_t ) VULKAN_HPP_NOEXCEPT
     {
       return *v;
     }
 
+#  if VULKAN_HPP_CPP_VERSION < 20
     template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
+#  else
+    template <VulkanRAIIHandleType T>
+#  endif
     bool operator!=( std::nullptr_t, T const & v ) VULKAN_HPP_NOEXCEPT
     {
       return *v;

third_party/vulkan/vulkan_static_assertions.hpp

@@ -10588,4 +10588,14 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV>::value,
                           "PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV is not nothrow_move_constructible!" );
 
+//=== VK_NV_private_data_base_handle ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV ) ==
+                            sizeof( VkPhysicalDevicePrivateDataBaseHandleFeaturesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV>::value,
+                          "PhysicalDevicePrivateDataBaseHandleFeaturesNV is not nothrow_move_constructible!" );
+
 #endif

third_party/vulkan/vulkan_structs.hpp

@@ -56665,6 +56665,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceOrHostAddressConstAMDX;
   };
 #  endif
+
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   // wrapper struct for struct VkDevicePipelineBinaryInternalCacheControlKHR, see
@@ -138091,6 +138092,130 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
   };
 
+  // wrapper struct for struct VkPhysicalDevicePrivateDataBaseHandleFeaturesNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrivateDataBaseHandleFeaturesNV.html
+  struct PhysicalDevicePrivateDataBaseHandleFeaturesNV
+  {
+    using NativeType = VkPhysicalDevicePrivateDataBaseHandleFeaturesNV;
+
+    static bool const                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDevicePrivateDataBaseHandleFeaturesNV;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDevicePrivateDataBaseHandleFeaturesNV( Bool32 privateDataBaseHandle_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , privateDataBaseHandle{ privateDataBaseHandle_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR
+      PhysicalDevicePrivateDataBaseHandleFeaturesNV( PhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDevicePrivateDataBaseHandleFeaturesNV( VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDevicePrivateDataBaseHandleFeaturesNV( *reinterpret_cast<PhysicalDevicePrivateDataBaseHandleFeaturesNV const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDevicePrivateDataBaseHandleFeaturesNV & operator=( PhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    PhysicalDevicePrivateDataBaseHandleFeaturesNV & operator=( VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<PhysicalDevicePrivateDataBaseHandleFeaturesNV const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataBaseHandleFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataBaseHandleFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataBaseHandleFeaturesNV & setPrivateDataBaseHandle( Bool32 privateDataBaseHandle_ ) & VULKAN_HPP_NOEXCEPT
+    {
+      privateDataBaseHandle = privateDataBaseHandle_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataBaseHandleFeaturesNV && setPrivateDataBaseHandle( Bool32 privateDataBaseHandle_ ) && VULKAN_HPP_NOEXCEPT
+    {
+      privateDataBaseHandle = privateDataBaseHandle_;
+      return std::move( *this );
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
+    operator VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const *>( this );
+    }
+
+    operator VkPhysicalDevicePrivateDataBaseHandleFeaturesNV &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV *>( this );
+    }
+
+    operator VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const *>( this );
+    }
+
+    operator VkPhysicalDevicePrivateDataBaseHandleFeaturesNV *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<StructureType const &, void * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, privateDataBaseHandle );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDevicePrivateDataBaseHandleFeaturesNV const & ) const = default;
+#else
+    bool operator==( PhysicalDevicePrivateDataBaseHandleFeaturesNV 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 ) && ( privateDataBaseHandle == rhs.privateDataBaseHandle );
+#  endif
+    }
+
+    bool operator!=( PhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    StructureType sType                 = StructureType::ePhysicalDevicePrivateDataBaseHandleFeaturesNV;
+    void *        pNext                 = {};
+    Bool32        privateDataBaseHandle = {};
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV>
+  {
+    using Type = PhysicalDevicePrivateDataBaseHandleFeaturesNV;
+  };
+#endif
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDevicePrivateDataBaseHandleFeaturesNV>
+  {
+    using Type = PhysicalDevicePrivateDataBaseHandleFeaturesNV;
+  };
+
   // wrapper struct for struct VkPhysicalDevicePrivateDataFeatures, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrivateDataFeatures.html
   struct PhysicalDevicePrivateDataFeatures

third_party/vulkan/vulkan_to_string.hpp

@@ -1650,9 +1650,17 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     return result;
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlags )
+  VULKAN_HPP_INLINE std::string to_string( PrivateDataSlotCreateFlags value )
   {
-    return "{}";
+    std::string result = "{";
+    if ( value & PrivateDataSlotCreateFlagBits::eBaseObjectHandleNV )
+      result += " BaseObjectHandleNV |";
+
+    if ( result.size() > 1 )
+      result.back() = '}';
+    else
+      result = "{}";
+    return result;
   }
 
   VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags2 value )
@@ -6202,6 +6210,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceImageTilingControlFeaturesEXT          : return "PhysicalDeviceImageTilingControlFeaturesEXT";
       case StructureType::eImageTilingControlCreateInfoEXT                      : return "ImageTilingControlCreateInfoEXT";
       case StructureType::ePhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV: return "PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV";
+      case StructureType::ePhysicalDevicePrivateDataBaseHandleFeaturesNV        : return "PhysicalDevicePrivateDataBaseHandleFeaturesNV";
       default                                                                   : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -8347,9 +8356,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlagBits )
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlagBits value )
   {
-    return "(void)";
+    switch ( value )
+    {
+      case PrivateDataSlotCreateFlagBits::eBaseObjectHandleNV: return "BaseObjectHandleNV";
+      default                                                : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
+    }
   }
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineStageFlagBits2 value )

third_party/vulkan/vulkan_video.cppm

@@ -51,6 +51,7 @@ module;
 
 export module vulkan_video;
 
+import std;
 import vulkan;
 
 #if defined( __clang__ )