Merge pull request #661 from asuessenbach/146

Update to VK_HEADER_VERSION 146.

Vulkan-Headers

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

vulkan/vulkan.hpp

@@ -88,7 +88,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION == 145, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 146, "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
@@ -3976,6 +3976,16 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
     }
 
+#  ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    VkResult vkCreateDirectFBSurfaceEXT( VkInstance                             instance,
+                                         const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
+                                         const VkAllocationCallbacks *          pAllocator,
+                                         VkSurfaceKHR *                         pSurface ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+    }
+#  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
     VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance                            instance,
                                              const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
                                              const VkAllocationCallbacks *         pAllocator,
@@ -4276,6 +4286,15 @@ namespace VULKAN_HPP_NAMESPACE
       return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
     }
 
+#  ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice,
+                                                                uint32_t         queueFamilyIndex,
+                                                                IDirectFB *      dfb ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
+    }
+#  endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
     VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice               physicalDevice,
                                                             uint32_t *                     pPropertyCount,
                                                             VkDisplayPlaneProperties2KHR * pProperties ) const
@@ -7522,7 +7541,8 @@ namespace VULKAN_HPP_NAMESPACE
 
   enum class ImageViewCreateFlagBits : VkImageViewCreateFlags
   {
-    eFragmentDensityMapDynamicEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT
+    eFragmentDensityMapDynamicEXT  = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT,
+    eFragmentDensityMapDeferredEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT
   };
 
   VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlagBits value )
@@ -7530,6 +7550,7 @@ namespace VULKAN_HPP_NAMESPACE
     switch ( value )
     {
       case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT: return "FragmentDensityMapDynamicEXT";
+      case ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT: return "FragmentDensityMapDeferredEXT";
       default: return "invalid";
     }
   }
@@ -9728,6 +9749,11 @@ namespace VULKAN_HPP_NAMESPACE
       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT,
     ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
     eDeviceDiagnosticsConfigCreateInfoNV       = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
+    ePhysicalDeviceFragmentDensityMap2FeaturesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
+    ePhysicalDeviceFragmentDensityMap2PropertiesEXT =
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
+    eDirectfbSurfaceCreateInfoEXT            = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT,
     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,
@@ -10407,6 +10433,11 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV:
         return "PhysicalDeviceDiagnosticsConfigFeaturesNV";
       case StructureType::eDeviceDiagnosticsConfigCreateInfoNV: return "DeviceDiagnosticsConfigCreateInfoNV";
+      case StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT:
+        return "PhysicalDeviceFragmentDensityMap2FeaturesEXT";
+      case StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT:
+        return "PhysicalDeviceFragmentDensityMap2PropertiesEXT";
+      case StructureType::eDirectfbSurfaceCreateInfoEXT: return "DirectfbSurfaceCreateInfoEXT";
       default: return "invalid";
     }
   }
@@ -12211,6 +12242,24 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+  enum class DirectFBSurfaceCreateFlagBitsEXT : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DirectFBSurfaceCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
+  using DirectFBSurfaceCreateFlagsEXT = Flags<DirectFBSurfaceCreateFlagBitsEXT>;
+
+  VULKAN_HPP_INLINE std::string to_string( DirectFBSurfaceCreateFlagsEXT )
+  {
+    return "{}";
+  }
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
   enum class DisplayModeCreateFlagBitsKHR : VkFlags
   {
   };
@@ -13407,7 +13456,8 @@ namespace VULKAN_HPP_NAMESPACE
   {
     enum : VkFlags
     {
-      allFlags = VkFlags( ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT )
+      allFlags = VkFlags( ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT ) |
+                 VkFlags( ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT )
     };
   };
 
@@ -13443,6 +13493,8 @@ namespace VULKAN_HPP_NAMESPACE
 
     if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT )
       result += "FragmentDensityMapDynamicEXT | ";
+    if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT )
+      result += "FragmentDensityMapDeferredEXT | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
@@ -16606,6 +16658,9 @@ namespace VULKAN_HPP_NAMESPACE
   struct DeviceQueueCreateInfo;
   struct DeviceQueueGlobalPriorityCreateInfoEXT;
   struct DeviceQueueInfo2;
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+  struct DirectFBSurfaceCreateInfoEXT;
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
   struct DispatchIndirectCommand;
   struct DisplayEventInfoEXT;
   struct DisplayModeCreateInfoKHR;
@@ -16860,6 +16915,8 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
   struct PhysicalDeviceFloatControlsProperties;
   using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
+  struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
+  struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
   struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
@@ -25393,6 +25450,21 @@ namespace VULKAN_HPP_NAMESPACE
       getCooperativeMatrixPropertiesNV( Allocator const & vectorAllocator, Dispatch const & d ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Bool32
+      getDirectFBPresentationSupportEXT( uint32_t         queueFamilyIndex,
+                                         IDirectFB *      dfb,
+                                         Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Bool32
+      getDirectFBPresentationSupportEXT( uint32_t         queueFamilyIndex,
+                                         IDirectFB &      dfb,
+                                         Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     Result
       getDisplayPlaneProperties2KHR( uint32_t *                                         pPropertyCount,
@@ -26305,6 +26377,28 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
+                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
+                                     VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
+                                     Dispatch const & d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+      createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
+                                Optional<const AllocationCallbacks>  allocator = nullptr,
+                                Dispatch const &                     d         = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+      createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
+                                      Optional<const AllocationCallbacks>  allocator = nullptr,
+                                      Dispatch const &                     d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     Result createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
@@ -41890,6 +41984,109 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = DeviceQueueInfo2;
   };
 
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+  struct DirectFBSurfaceCreateInfoEXT
+  {
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDirectfbSurfaceCreateInfoEXT;
+
+#  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR DirectFBSurfaceCreateInfoEXT( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT flags_ = {},
+                                                       IDirectFB *                                         dfb_   = {},
+                                                       IDirectFBSurface * surface_ = {} ) VULKAN_HPP_NOEXCEPT
+      : flags( flags_ )
+      , dfb( dfb_ )
+      , surface( surface_ )
+    {}
+
+    DirectFBSurfaceCreateInfoEXT( VkDirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+#  endif  // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    DirectFBSurfaceCreateInfoEXT & operator=( VkDirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const *>( &rhs );
+      return *this;
+    }
+
+    DirectFBSurfaceCreateInfoEXT & operator=( DirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy(
+        &pNext, &rhs.pNext, sizeof( DirectFBSurfaceCreateInfoEXT ) - offsetof( DirectFBSurfaceCreateInfoEXT, pNext ) );
+      return *this;
+    }
+
+    DirectFBSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    DirectFBSurfaceCreateInfoEXT &
+      setFlags( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    DirectFBSurfaceCreateInfoEXT & setDfb( IDirectFB * dfb_ ) VULKAN_HPP_NOEXCEPT
+    {
+      dfb = dfb_;
+      return *this;
+    }
+
+    DirectFBSurfaceCreateInfoEXT & setSurface( IDirectFBSurface * surface_ ) VULKAN_HPP_NOEXCEPT
+    {
+      surface = surface_;
+      return *this;
+    }
+
+    operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( this );
+    }
+
+    operator VkDirectFBSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkDirectFBSurfaceCreateInfoEXT *>( this );
+    }
+
+#  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( DirectFBSurfaceCreateInfoEXT const & ) const = default;
+#  else
+    bool operator==( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) &&
+             ( surface == rhs.surface );
+    }
+
+    bool operator!=( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#  endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType           sType   = StructureType::eDirectfbSurfaceCreateInfoEXT;
+    const void *                                        pNext   = {};
+    VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT flags   = {};
+    IDirectFB *                                         dfb     = {};
+    IDirectFBSurface *                                  surface = {};
+  };
+  static_assert( sizeof( DirectFBSurfaceCreateInfoEXT ) == sizeof( VkDirectFBSurfaceCreateInfoEXT ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<DirectFBSurfaceCreateInfoEXT>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::eDirectfbSurfaceCreateInfoEXT>
+  {
+    using Type = DirectFBSurfaceCreateInfoEXT;
+  };
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
   struct DispatchIndirectCommand
   {
 #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
@@ -59545,6 +59742,186 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceFloatControlsProperties;
   };
 
+  struct PhysicalDeviceFragmentDensityMap2FeaturesEXT
+  {
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2FeaturesEXT(
+      VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapDeferred_ = {} ) VULKAN_HPP_NOEXCEPT
+      : fragmentDensityMapDeferred( fragmentDensityMapDeferred_ )
+    {}
+
+    PhysicalDeviceFragmentDensityMap2FeaturesEXT( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs )
+      VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+#endif  // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    PhysicalDeviceFragmentDensityMap2FeaturesEXT &
+      operator=( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const *>( &rhs );
+      return *this;
+    }
+
+    PhysicalDeviceFragmentDensityMap2FeaturesEXT &
+      operator=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext,
+              &rhs.pNext,
+              sizeof( PhysicalDeviceFragmentDensityMap2FeaturesEXT ) -
+                offsetof( PhysicalDeviceFragmentDensityMap2FeaturesEXT, pNext ) );
+      return *this;
+    }
+
+    PhysicalDeviceFragmentDensityMap2FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceFragmentDensityMap2FeaturesEXT &
+      setFragmentDensityMapDeferred( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapDeferred_ ) VULKAN_HPP_NOEXCEPT
+    {
+      fragmentDensityMapDeferred = fragmentDensityMapDeferred_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>( this );
+    }
+
+    operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred );
+    }
+
+    bool operator!=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT;
+    void *                                    pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32              fragmentDensityMapDeferred = {};
+  };
+  static_assert( sizeof( PhysicalDeviceFragmentDensityMap2FeaturesEXT ) ==
+                   sizeof( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMap2FeaturesEXT>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT>
+  {
+    using Type = PhysicalDeviceFragmentDensityMap2FeaturesEXT;
+  };
+
+  struct PhysicalDeviceFragmentDensityMap2PropertiesEXT
+  {
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2PropertiesEXT(
+      VULKAN_HPP_NAMESPACE::Bool32 subsampledLoads_                           = {},
+      VULKAN_HPP_NAMESPACE::Bool32 subsampledCoarseReconstructionEarlyAccess_ = {},
+      uint32_t                     maxSubsampledArrayLayers_                  = {},
+      uint32_t                     maxDescriptorSetSubsampledSamplers_        = {} ) VULKAN_HPP_NOEXCEPT
+      : subsampledLoads( subsampledLoads_ )
+      , subsampledCoarseReconstructionEarlyAccess( subsampledCoarseReconstructionEarlyAccess_ )
+      , maxSubsampledArrayLayers( maxSubsampledArrayLayers_ )
+      , maxDescriptorSetSubsampledSamplers( maxDescriptorSetSubsampledSamplers_ )
+    {}
+
+    PhysicalDeviceFragmentDensityMap2PropertiesEXT( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs )
+      VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+#endif  // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    PhysicalDeviceFragmentDensityMap2PropertiesEXT &
+      operator=( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const *>( &rhs );
+      return *this;
+    }
+
+    PhysicalDeviceFragmentDensityMap2PropertiesEXT &
+      operator=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext,
+              &rhs.pNext,
+              sizeof( PhysicalDeviceFragmentDensityMap2PropertiesEXT ) -
+                offsetof( PhysicalDeviceFragmentDensityMap2PropertiesEXT, pNext ) );
+      return *this;
+    }
+
+    operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>( this );
+    }
+
+    operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) &&
+             ( subsampledCoarseReconstructionEarlyAccess == rhs.subsampledCoarseReconstructionEarlyAccess ) &&
+             ( maxSubsampledArrayLayers == rhs.maxSubsampledArrayLayers ) &&
+             ( maxDescriptorSetSubsampledSamplers == rhs.maxDescriptorSetSubsampledSamplers );
+    }
+
+    bool operator!=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT;
+    void *                                    pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32              subsampledLoads                           = {};
+    VULKAN_HPP_NAMESPACE::Bool32              subsampledCoarseReconstructionEarlyAccess = {};
+    uint32_t                                  maxSubsampledArrayLayers                  = {};
+    uint32_t                                  maxDescriptorSetSubsampledSamplers        = {};
+  };
+  static_assert( sizeof( PhysicalDeviceFragmentDensityMap2PropertiesEXT ) ==
+                   sizeof( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMap2PropertiesEXT>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT>
+  {
+    using Type = PhysicalDeviceFragmentDensityMap2PropertiesEXT;
+  };
+
   struct PhysicalDeviceFragmentDensityMapFeaturesEXT
   {
     static const bool                                  allowDuplicate = false;
@@ -59585,6 +59962,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+    PhysicalDeviceFragmentDensityMapFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceFragmentDensityMapFeaturesEXT &
+      setFragmentDensityMap( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMap_ ) VULKAN_HPP_NOEXCEPT
+    {
+      fragmentDensityMap = fragmentDensityMap_;
+      return *this;
+    }
+
+    PhysicalDeviceFragmentDensityMapFeaturesEXT &
+      setFragmentDensityMapDynamic( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapDynamic_ ) VULKAN_HPP_NOEXCEPT
+    {
+      fragmentDensityMapDynamic = fragmentDensityMapDynamic_;
+      return *this;
+    }
+
+    PhysicalDeviceFragmentDensityMapFeaturesEXT & setFragmentDensityMapNonSubsampledImages(
+      VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapNonSubsampledImages_ ) VULKAN_HPP_NOEXCEPT
+    {
+      fragmentDensityMapNonSubsampledImages = fragmentDensityMapNonSubsampledImages_;
+      return *this;
+    }
+
     operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>( this );
@@ -93678,6 +94082,57 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Result
+    Instance::createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
+                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
+                                        VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
+                                        Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Result>(
+      d.vkCreateDirectFBSurfaceEXT( m_instance,
+                                    reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( pCreateInfo ),
+                                    reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                    reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
+  }
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
+    Instance::createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
+                                        Optional<const AllocationCallbacks>  allocator,
+                                        Dispatch const &                     d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>( d.vkCreateDirectFBSurfaceEXT(
+      m_instance,
+      reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+    return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" );
+  }
+#    ifndef VULKAN_HPP_NO_SMART_HANDLE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR, Dispatch>>::type
+    Instance::createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
+                                              Optional<const AllocationCallbacks>  allocator,
+                                              Dispatch const &                     d ) const
+  {
+    VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
+    Result                           result = static_cast<Result>( d.vkCreateDirectFBSurfaceEXT(
+      m_instance,
+      reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
+
+    ObjectDestroy<Instance, Dispatch> deleter( *this, allocator, d );
+    return createResultValue<SurfaceKHR, Dispatch>(
+      result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique", deleter );
+  }
+#    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
+#  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
   template <typename Dispatch>
   VULKAN_HPP_INLINE Result
     Instance::createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
@@ -95470,6 +95925,24 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT(
+    uint32_t queueFamilyIndex, IDirectFB * dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return static_cast<Bool32>(
+      d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, dfb ) );
+  }
+#  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT(
+    uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    return d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb );
+  }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+#endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
   template <typename Dispatch>
   VULKAN_HPP_INLINE Result
     PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t *                                         pPropertyCount,
@@ -98887,6 +99360,30 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceFragmentDensityMap2PropertiesEXT, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, PhysicalDeviceFeatures2>
   {
     enum
@@ -100946,6 +101443,9 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
     PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0;
     PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0;
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0;
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
     PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0;
     PFN_vkCreateHeadlessSurfaceEXT     vkCreateHeadlessSurfaceEXT     = 0;
 #ifdef VK_USE_PLATFORM_IOS_MVK
@@ -101004,6 +101504,9 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkGetDisplayPlaneSupportedDisplaysKHR            vkGetDisplayPlaneSupportedDisplaysKHR            = 0;
     PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT   vkGetPhysicalDeviceCalibrateableTimeDomainsEXT   = 0;
     PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0;
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0;
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
     PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR      vkGetPhysicalDeviceDisplayPlaneProperties2KHR      = 0;
     PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR       vkGetPhysicalDeviceDisplayPlanePropertiesKHR       = 0;
     PFN_vkGetPhysicalDeviceDisplayProperties2KHR           vkGetPhysicalDeviceDisplayProperties2KHR           = 0;
@@ -101169,6 +101672,10 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) );
       vkCreateDebugUtilsMessengerEXT =
         PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) );
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+      vkCreateDirectFBSurfaceEXT =
+        PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) );
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
       vkCreateDisplayPlaneSurfaceKHR =
         PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) );
       vkCreateHeadlessSurfaceEXT =
@@ -101254,6 +101761,10 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
       vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) );
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+      vkGetPhysicalDeviceDirectFBPresentationSupportEXT = PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) );
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
       vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
         vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) );
       vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(