Merge pull request #838 from asuessenbach/164

Update to VK_HEADER_VERSION 164.

Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 6a163aa97f8a3d1c186138bedbfb76ce117be8d1
+Subproject commit fe9850767d00e46b230da6cfbc15eb86636017bd

VulkanHppGenerator.cpp

@@ -2804,13 +2804,7 @@ ${CppTypeFromDebugReportObjectTypeEXT}
     std::string enter, leave;
     std::tie( enter, leave ) = generateProtection( handleData.first, !handleData.second.alias.empty() );
 
-    std::string objTypeEnum;
+    assert( !handleData.second.objTypeEnum.empty() );
-    if ( handleData.second.objTypeEnum.empty() )
-    {
-      objTypeEnum = "e" + stripPrefix( handleData.first, "Vk" );
-    }
-    else
-    {
     enumIt = m_enums.find( "VkObjectType" );
     assert( enumIt != m_enums.end() );
     valueIt = std::find_if(
@@ -2818,8 +2812,6 @@ ${CppTypeFromDebugReportObjectTypeEXT}
         return evd.vulkanValue == handleData.second.objTypeEnum;
       } );
     assert( valueIt != enumIt->second.values.end() );
-      objTypeEnum = valueIt->vkValue;
-    }
 
     str += replaceWithMap( templateString,
                            { { "className", className },
@@ -2828,7 +2820,7 @@ ${CppTypeFromDebugReportObjectTypeEXT}
                              { "debugReportObjectType", debugReportObjectType },
                              { "enter", enter },
                              { "memberName", startLowerCase( stripPrefix( handleData.first, "Vk" ) ) },
-                             { "objTypeEnum", objTypeEnum } } );
+                             { "objTypeEnum", valueIt->vkValue } } );
 
     if ( !handleData.second.alias.empty() )
     {
@@ -6598,18 +6590,7 @@ void VulkanHppGenerator::checkCorrectness()
 
     if ( !handle.first.empty() )
     {
-      if ( handle.second.objTypeEnum.empty() )
+      assert( !handle.second.objTypeEnum.empty() );
-      {
-        std::string objectType = "e" + stripPrefix( handle.first, "Vk" );
-        auto        valueIt    = std::find_if( objectTypeIt->second.values.begin(),
-                                     objectTypeIt->second.values.end(),
-                                     [&objectType]( EnumValueData const & evd ) { return evd.vkValue == objectType; } );
-        check( valueIt != objectTypeIt->second.values.end(),
-               handle.second.xmlLine,
-               "handle <" + handle.first + "> specified without corresponding VkObjectType enum value" );
-      }
-      else
-      {
       check( std::find_if( objectTypeIt->second.values.begin(),
                             objectTypeIt->second.values.end(),
                             [&handle]( EnumValueData const & evd ) {
@@ -6619,12 +6600,11 @@ void VulkanHppGenerator::checkCorrectness()
               "handle <" + handle.first + "> specifies unknown \"objtypeenum\" <" + handle.second.objTypeEnum + ">" );
     }
   }
-  }
   for ( auto const & objectTypeValue : objectTypeIt->second.values )
   {
     if ( objectTypeValue.vkValue != "eUnknown" )
     {
-      warn( std::find_if( m_handles.begin(),
+      check( std::find_if( m_handles.begin(),
                           m_handles.end(),
                           [&objectTypeValue]( std::pair<std::string, HandleData> const & hd ) {
                             return hd.second.objTypeEnum == objectTypeValue.vulkanValue;
@@ -8533,7 +8513,7 @@ void VulkanHppGenerator::readHandle( tinyxml2::XMLElement const *
            "handle with invalid type <" + typeInfo.type + ">" );
     check( typeInfo.prefix.empty(), line, "unexpected type prefix <" + typeInfo.prefix + ">" );
     check( typeInfo.postfix == "(", line, "unexpected type postfix <" + typeInfo.postfix + ">" );
-    warn( !objTypeEnum.empty(), line, "handle <" + nameData.name + "> does not specify attribute \"objtypeenum\"" );
+    check( !objTypeEnum.empty(), line, "handle <" + nameData.name + "> does not specify attribute \"objtypeenum\"" );
 
     check( m_handles.insert( std::make_pair( nameData.name, HandleData( tokenize( parent, "," ), objTypeEnum, line ) ) )
              .second,
@@ -9182,6 +9162,15 @@ void VulkanHppGenerator::readStruct( tinyxml2::XMLElement const *
         readStructMember( child, it->second.members, isUnion );
       }
     }
+    if ( name == "VkDescriptorSetAllocateInfo" )
+    {
+      // some very very very special handling for this struct: the "len" attribute for pSetLayouts has gone!
+      assert( ( it->second.members.size() == 5 ) && ( it->second.members[3].name == "descriptorSetCount" ) && ( it->second.members[4].name == "pSetLayouts" ));
+      warn( !it->second.members[4].len.empty(),
+            line,
+            "Missing attribute \"len\" for member <descriptorSetCount> in structure <VkDescriptorSetAllocateInfo>" );
+      it->second.members[4].len = { it->second.members[3].name };
+    }
     it->second.subStruct = determineSubStruct( *it );
 
     m_extendedStructs.insert( structExtends.begin(), structExtends.end() );

vulkan/vulkan.hpp

@@ -93,7 +93,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION == 163, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 164, "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
@@ -1276,6 +1276,13 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkAcquireProfilingLockKHR( device, pInfo );
     }
 
+#  ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
 #  ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice,
                                       Display *        dpy,
@@ -4472,6 +4479,15 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
     }
 
+#  ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice,
+                                  uint32_t         deviceRelativeId,
+                                  VkDisplayKHR *   pDisplay ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
+    }
+#  endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
     VkResult vkImportFenceFdKHR( VkDevice                       device,
                                  const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
     {
@@ -6204,6 +6220,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     eFreeDescriptorSet  = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
     eUpdateAfterBind    = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
+    eHostOnlyVALVE      = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE,
     eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT
   };
 
@@ -6213,6 +6230,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet";
       case DescriptorPoolCreateFlagBits::eUpdateAfterBind: return "UpdateAfterBind";
+      case DescriptorPoolCreateFlagBits::eHostOnlyVALVE: return "HostOnlyVALVE";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -6221,6 +6239,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     eUpdateAfterBindPool    = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
     ePushDescriptorKHR      = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,
+    eHostOnlyPoolVALVE      = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE,
     eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
   };
 
@@ -6230,6 +6249,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
       case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool: return "UpdateAfterBindPool";
       case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR";
+      case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE: return "HostOnlyPoolVALVE";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -6249,7 +6269,8 @@ namespace VULKAN_HPP_NAMESPACE
     eInputAttachment          = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
     eInlineUniformBlockEXT    = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
     eAccelerationStructureKHR = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
-    eAccelerationStructureNV  = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV
+    eAccelerationStructureNV  = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV,
+    eMutableVALVE             = VK_DESCRIPTOR_TYPE_MUTABLE_VALVE
   };
 
   VULKAN_HPP_INLINE std::string to_string( DescriptorType value )
@@ -6270,6 +6291,7 @@ namespace VULKAN_HPP_NAMESPACE
       case DescriptorType::eInlineUniformBlockEXT: return "InlineUniformBlockEXT";
       case DescriptorType::eAccelerationStructureKHR: return "AccelerationStructureKHR";
       case DescriptorType::eAccelerationStructureNV: return "AccelerationStructureNV";
+      case DescriptorType::eMutableVALVE: return "MutableVALVE";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -10076,6 +10098,9 @@ namespace VULKAN_HPP_NAMESPACE
     eImageResolve2KHR                         = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
     ePhysicalDevice4444FormatsFeaturesEXT     = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT,
     eDirectfbSurfaceCreateInfoEXT             = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT,
+    ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE,
+    eMutableDescriptorTypeCreateInfoVALVE    = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE,
     eAttachmentDescription2KHR               = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,
     eAttachmentDescriptionStencilLayoutKHR   = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
     eAttachmentReference2KHR                 = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,
@@ -10804,6 +10829,9 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eImageResolve2KHR: return "ImageResolve2KHR";
       case StructureType::ePhysicalDevice4444FormatsFeaturesEXT: return "PhysicalDevice4444FormatsFeaturesEXT";
       case StructureType::eDirectfbSurfaceCreateInfoEXT: return "DirectfbSurfaceCreateInfoEXT";
+      case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE:
+        return "PhysicalDeviceMutableDescriptorTypeFeaturesVALVE";
+      case StructureType::eMutableDescriptorTypeCreateInfoVALVE: return "MutableDescriptorTypeCreateInfoVALVE";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -11105,7 +11133,8 @@ namespace VULKAN_HPP_NAMESPACE
     eVSI      = VK_VENDOR_ID_VSI,
     eKazan    = VK_VENDOR_ID_KAZAN,
     eCodeplay = VK_VENDOR_ID_CODEPLAY,
-    eMESA     = VK_VENDOR_ID_MESA
+    eMESA     = VK_VENDOR_ID_MESA,
+    ePocl     = VK_VENDOR_ID_POCL
   };
 
   VULKAN_HPP_INLINE std::string to_string( VendorId value )
@@ -11117,6 +11146,7 @@ namespace VULKAN_HPP_NAMESPACE
       case VendorId::eKazan: return "Kazan";
       case VendorId::eCodeplay: return "Codeplay";
       case VendorId::eMESA: return "MESA";
+      case VendorId::ePocl: return "Pocl";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -12379,7 +12409,8 @@ namespace VULKAN_HPP_NAMESPACE
     enum : VkFlags
     {
       allFlags = VkFlags( DescriptorPoolCreateFlagBits::eFreeDescriptorSet ) |
-                 VkFlags( DescriptorPoolCreateFlagBits::eUpdateAfterBind )
+                 VkFlags( DescriptorPoolCreateFlagBits::eUpdateAfterBind ) |
+                 VkFlags( DescriptorPoolCreateFlagBits::eHostOnlyVALVE )
     };
   };
 
@@ -12417,6 +12448,8 @@ namespace VULKAN_HPP_NAMESPACE
       result += "FreeDescriptorSet | ";
     if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBind )
       result += "UpdateAfterBind | ";
+    if ( value & DescriptorPoolCreateFlagBits::eHostOnlyVALVE )
+      result += "HostOnlyVALVE | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
@@ -12444,7 +12477,8 @@ namespace VULKAN_HPP_NAMESPACE
     enum : VkFlags
     {
       allFlags = VkFlags( DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool ) |
-                 VkFlags( DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR )
+                 VkFlags( DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR ) |
+                 VkFlags( DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE )
     };
   };
 
@@ -12482,6 +12516,8 @@ namespace VULKAN_HPP_NAMESPACE
       result += "UpdateAfterBindPool | ";
     if ( value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR )
       result += "PushDescriptorKHR | ";
+    if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE )
+      result += "HostOnlyPoolVALVE | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
@@ -60733,6 +60769,20 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #endif
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  else
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
+         acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
+                                Dispatch const & d               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD Result
@@ -61932,6 +61982,26 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result
+      getWinrtDisplayNV( uint32_t                           deviceRelativeId,
+                         VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
+                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
+      getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+      typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
+      getWinrtDisplayNVUnique( uint32_t           deviceRelativeId,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_WIN32_KHR*/
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
@@ -68288,6 +68358,224 @@ namespace VULKAN_HPP_NAMESPACE
   };
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
 
+  struct MutableDescriptorTypeListVALVE
+  {
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListVALVE(
+      uint32_t                                     descriptorTypeCount_ = {},
+      const VULKAN_HPP_NAMESPACE::DescriptorType * pDescriptorTypes_    = {} ) VULKAN_HPP_NOEXCEPT
+      : descriptorTypeCount( descriptorTypeCount_ )
+      , pDescriptorTypes( pDescriptorTypes_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR
+      MutableDescriptorTypeListVALVE( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    MutableDescriptorTypeListVALVE( VkMutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    MutableDescriptorTypeListVALVE(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorType> const &
+        descriptorTypes_ )
+      : descriptorTypeCount( static_cast<uint32_t>( descriptorTypes_.size() ) )
+      , pDescriptorTypes( descriptorTypes_.data() )
+    {}
+#  endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+#endif    // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    MutableDescriptorTypeListVALVE & operator=( VkMutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE const *>( &rhs );
+      return *this;
+    }
+
+    MutableDescriptorTypeListVALVE & operator=( MutableDescriptorTypeListVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MutableDescriptorTypeListVALVE ) );
+      return *this;
+    }
+
+    MutableDescriptorTypeListVALVE & setDescriptorTypeCount( uint32_t descriptorTypeCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      descriptorTypeCount = descriptorTypeCount_;
+      return *this;
+    }
+
+    MutableDescriptorTypeListVALVE &
+      setPDescriptorTypes( const VULKAN_HPP_NAMESPACE::DescriptorType * pDescriptorTypes_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pDescriptorTypes = pDescriptorTypes_;
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    MutableDescriptorTypeListVALVE & setDescriptorTypes(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::DescriptorType> const &
+        descriptorTypes_ ) VULKAN_HPP_NOEXCEPT
+    {
+      descriptorTypeCount = static_cast<uint32_t>( descriptorTypes_.size() );
+      pDescriptorTypes    = descriptorTypes_.data();
+      return *this;
+    }
+#endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+
+    operator VkMutableDescriptorTypeListVALVE const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkMutableDescriptorTypeListVALVE *>( this );
+    }
+
+    operator VkMutableDescriptorTypeListVALVE &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkMutableDescriptorTypeListVALVE *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( MutableDescriptorTypeListVALVE const & ) const = default;
+#else
+    bool operator==( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes );
+    }
+
+    bool operator!=( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    uint32_t                                     descriptorTypeCount = {};
+    const VULKAN_HPP_NAMESPACE::DescriptorType * pDescriptorTypes    = {};
+  };
+  static_assert( sizeof( MutableDescriptorTypeListVALVE ) == sizeof( VkMutableDescriptorTypeListVALVE ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<MutableDescriptorTypeListVALVE>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  struct MutableDescriptorTypeCreateInfoVALVE
+  {
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::eMutableDescriptorTypeCreateInfoVALVE;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoVALVE(
+      uint32_t                                                     mutableDescriptorTypeListCount_ = {},
+      const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE * pMutableDescriptorTypeLists_    = {} )
+      VULKAN_HPP_NOEXCEPT
+      : mutableDescriptorTypeListCount( mutableDescriptorTypeListCount_ )
+      , pMutableDescriptorTypeLists( pMutableDescriptorTypeLists_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoVALVE( MutableDescriptorTypeCreateInfoVALVE const & rhs )
+      VULKAN_HPP_NOEXCEPT = default;
+
+    MutableDescriptorTypeCreateInfoVALVE( VkMutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    MutableDescriptorTypeCreateInfoVALVE(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE> const &
+        mutableDescriptorTypeLists_ )
+      : mutableDescriptorTypeListCount( static_cast<uint32_t>( mutableDescriptorTypeLists_.size() ) )
+      , pMutableDescriptorTypeLists( mutableDescriptorTypeLists_.data() )
+    {}
+#  endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+#endif    // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    MutableDescriptorTypeCreateInfoVALVE &
+      operator=( VkMutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE const *>( &rhs );
+      return *this;
+    }
+
+    MutableDescriptorTypeCreateInfoVALVE &
+      operator=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( MutableDescriptorTypeCreateInfoVALVE ) );
+      return *this;
+    }
+
+    MutableDescriptorTypeCreateInfoVALVE & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    MutableDescriptorTypeCreateInfoVALVE &
+      setMutableDescriptorTypeListCount( uint32_t mutableDescriptorTypeListCount_ ) VULKAN_HPP_NOEXCEPT
+    {
+      mutableDescriptorTypeListCount = mutableDescriptorTypeListCount_;
+      return *this;
+    }
+
+    MutableDescriptorTypeCreateInfoVALVE & setPMutableDescriptorTypeLists(
+      const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE * pMutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pMutableDescriptorTypeLists = pMutableDescriptorTypeLists_;
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    MutableDescriptorTypeCreateInfoVALVE & setMutableDescriptorTypeLists(
+      VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE> const &
+        mutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT
+    {
+      mutableDescriptorTypeListCount = static_cast<uint32_t>( mutableDescriptorTypeLists_.size() );
+      pMutableDescriptorTypeLists    = mutableDescriptorTypeLists_.data();
+      return *this;
+    }
+#endif  // !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
+
+    operator VkMutableDescriptorTypeCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE *>( this );
+    }
+
+    operator VkMutableDescriptorTypeCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const & ) const = default;
+#else
+    bool operator==( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) &&
+             ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists );
+    }
+
+    bool operator!=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMutableDescriptorTypeCreateInfoVALVE;
+    const void *                              pNext = {};
+    uint32_t                                  mutableDescriptorTypeListCount                 = {};
+    const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE * pMutableDescriptorTypeLists = {};
+  };
+  static_assert( sizeof( MutableDescriptorTypeCreateInfoVALVE ) == sizeof( VkMutableDescriptorTypeCreateInfoVALVE ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<MutableDescriptorTypeCreateInfoVALVE>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eMutableDescriptorTypeCreateInfoVALVE>
+  {
+    using Type = MutableDescriptorTypeCreateInfoVALVE;
+  };
+
   union PerformanceCounterResultKHR
   {
     PerformanceCounterResultKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR const & rhs ) VULKAN_HPP_NOEXCEPT
@@ -75236,6 +75524,96 @@ namespace VULKAN_HPP_NAMESPACE
   };
   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
 
+  struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
+  {
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+      VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType_ = {} ) VULKAN_HPP_NOEXCEPT
+      : mutableDescriptorType( mutableDescriptorType_ )
+    {}
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+      PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs )
+      VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+#endif  // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE &
+      operator=( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const *>( &rhs );
+      return *this;
+    }
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE &
+      operator=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( static_cast<void *>( this ), &rhs, sizeof( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE ) );
+      return *this;
+    }
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesVALVE &
+      setMutableDescriptorType( VULKAN_HPP_NAMESPACE::Bool32 mutableDescriptorType_ ) VULKAN_HPP_NOEXCEPT
+    {
+      mutableDescriptorType = mutableDescriptorType_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>( this );
+    }
+
+    operator VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType );
+    }
+
+    bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+    void *                                    pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32              mutableDescriptorType = {};
+  };
+  static_assert( sizeof( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE ) ==
+                   sizeof( VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE>
+  {
+    using Type = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+  };
+
   struct PhysicalDevicePCIBusInfoPropertiesEXT
   {
     static const bool                                  allowDuplicate = false;
@@ -104074,6 +104452,26 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV(
+    VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+  }
+#  else
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
+                                          PhysicalDevice::acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const
+  {
+    Result result =
+      static_cast<Result>( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
+    return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_WIN32_KHR*/
+
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT(
@@ -107478,6 +107876,46 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 #endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
 
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    PhysicalDevice::getWinrtDisplayNV( uint32_t                           deviceRelativeId,
+                                       VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
+                                       Dispatch const &                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( pDisplay ) ) );
+  }
+
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
+    PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayKHR display;
+    Result                           result = static_cast<Result>(
+      d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
+    return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" );
+  }
+
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
+    typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
+    PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const
+  {
+    VULKAN_HPP_NAMESPACE::DisplayKHR display;
+    Result                           result = static_cast<Result>(
+      d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
+    ObjectRelease<PhysicalDevice, Dispatch> deleter( *this, d );
+    return createResultValue<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>(
+      result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_WIN32_KHR*/
+
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
@@ -108335,6 +108773,22 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorSetLayoutCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorPoolCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo>
   {
     enum
@@ -109175,6 +109629,22 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2>
   {
     enum
@@ -110665,6 +111135,9 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkAcquireNextImageKHR                  vkAcquireNextImageKHR                  = 0;
     PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0;
     PFN_vkAcquireProfilingLockKHR              vkAcquireProfilingLockKHR              = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
     PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0;
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
@@ -111113,6 +111586,9 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkGetSwapchainImagesKHR     vkGetSwapchainImagesKHR     = 0;
     PFN_vkGetSwapchainStatusKHR     vkGetSwapchainStatusKHR     = 0;
     PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
     PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
@@ -111252,6 +111728,10 @@ namespace VULKAN_HPP_NAMESPACE
     void init( VULKAN_HPP_NAMESPACE::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT
     {
       VkInstance instance = static_cast<VkInstance>( instanceCpp );
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkAcquireWinrtDisplayNV =
+        PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
       vkAcquireXlibDisplayEXT =
         PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
@@ -111490,6 +111970,9 @@ namespace VULKAN_HPP_NAMESPACE
       vkGetRandROutputDisplayEXT =
         PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+      vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
       vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
       vkSubmitDebugUtilsMessageEXT =
         PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );