Merge pull request #681 from asuessenbach/148

Update to VK_HEADER_VERSION 148.

Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 858b13a1220a20d2bed98779b99d38d797d070e5
+Subproject commit 83825d55c7d522931124696ecb07ed48f2693e5c

vulkan/vulkan.hpp

@@ -88,7 +88,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION == 147, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 148, "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
@@ -6294,6 +6294,7 @@ namespace VULKAN_HPP_NAMESPACE
     eGgpProprietary          = VK_DRIVER_ID_GGP_PROPRIETARY,
     eBroadcomProprietary     = VK_DRIVER_ID_BROADCOM_PROPRIETARY,
     eMesaLlvmpipe            = VK_DRIVER_ID_MESA_LLVMPIPE,
+    eMoltenvk                = VK_DRIVER_ID_MOLTENVK,
     eIntelOpenSourceMesa     = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR
   };
   using DriverIdKHR = DriverId;
@@ -6315,6 +6316,7 @@ namespace VULKAN_HPP_NAMESPACE
       case DriverId::eGgpProprietary: return "GgpProprietary";
       case DriverId::eBroadcomProprietary: return "BroadcomProprietary";
       case DriverId::eMesaLlvmpipe: return "MesaLlvmpipe";
+      case DriverId::eMoltenvk: return "Moltenvk";
       default: return "invalid";
     }
   }
@@ -6540,7 +6542,8 @@ namespace VULKAN_HPP_NAMESPACE
     eOpaqueWin32    = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
     eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
     eD3D12Fence     = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
-    eSyncFd         = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+    eSyncFd         = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
+    eD3D11Fence     = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT
   };
   using ExternalSemaphoreHandleTypeFlagBitsKHR = ExternalSemaphoreHandleTypeFlagBits;
 
@@ -9705,6 +9708,7 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceLineRasterizationFeaturesEXT   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
     ePipelineRasterizationLineStateCreateInfoEXT  = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
     ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
+    ePhysicalDeviceShaderAtomicFloatFeaturesEXT   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
     ePhysicalDeviceIndexTypeUint8FeaturesEXT      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
     ePhysicalDeviceExtendedDynamicStateFeaturesEXT =
       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
@@ -9753,6 +9757,7 @@ namespace VULKAN_HPP_NAMESPACE
       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
     ePhysicalDeviceFragmentDensityMap2PropertiesEXT =
       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
+    ePhysicalDeviceImageRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_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,
@@ -10385,6 +10390,8 @@ namespace VULKAN_HPP_NAMESPACE
         return "PipelineRasterizationLineStateCreateInfoEXT";
       case StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT:
         return "PhysicalDeviceLineRasterizationPropertiesEXT";
+      case StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT:
+        return "PhysicalDeviceShaderAtomicFloatFeaturesEXT";
       case StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT: return "PhysicalDeviceIndexTypeUint8FeaturesEXT";
       case StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT:
         return "PhysicalDeviceExtendedDynamicStateFeaturesEXT";
@@ -10437,6 +10444,7 @@ namespace VULKAN_HPP_NAMESPACE
         return "PhysicalDeviceFragmentDensityMap2FeaturesEXT";
       case StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT:
         return "PhysicalDeviceFragmentDensityMap2PropertiesEXT";
+      case StructureType::ePhysicalDeviceImageRobustnessFeaturesEXT: return "PhysicalDeviceImageRobustnessFeaturesEXT";
       case StructureType::eDirectfbSurfaceCreateInfoEXT: return "DirectfbSurfaceCreateInfoEXT";
       default: return "invalid";
     }
@@ -16930,6 +16938,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
   struct PhysicalDeviceImageFormatInfo2;
   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
+  struct PhysicalDeviceImageRobustnessFeaturesEXT;
   struct PhysicalDeviceImageViewImageFormatInfoEXT;
   struct PhysicalDeviceImagelessFramebufferFeatures;
   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
@@ -16986,6 +16995,7 @@ namespace VULKAN_HPP_NAMESPACE
   using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
   using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
+  struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
   struct PhysicalDeviceShaderAtomicInt64Features;
   using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
   struct PhysicalDeviceShaderClockFeaturesKHR;
@@ -62386,6 +62396,95 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceImageFormatInfo2;
   };
 
+  struct PhysicalDeviceImageRobustnessFeaturesEXT
+  {
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceImageRobustnessFeaturesEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceImageRobustnessFeaturesEXT(
+      VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess_ = {} ) VULKAN_HPP_NOEXCEPT
+      : robustImageAccess( robustImageAccess_ )
+    {}
+
+    PhysicalDeviceImageRobustnessFeaturesEXT( VkPhysicalDeviceImageRobustnessFeaturesEXT const & rhs )
+      VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+#endif  // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    PhysicalDeviceImageRobustnessFeaturesEXT &
+      operator=( VkPhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeaturesEXT const *>( &rhs );
+      return *this;
+    }
+
+    PhysicalDeviceImageRobustnessFeaturesEXT &
+      operator=( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext             = rhs.pNext;
+      robustImageAccess = rhs.robustImageAccess;
+
+      return *this;
+    }
+
+    PhysicalDeviceImageRobustnessFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceImageRobustnessFeaturesEXT &
+      setRobustImageAccess( VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess_ ) VULKAN_HPP_NOEXCEPT
+    {
+      robustImageAccess = robustImageAccess_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceImageRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT *>( this );
+    }
+
+    operator VkPhysicalDeviceImageRobustnessFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceImageRobustnessFeaturesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess );
+    }
+
+    bool operator!=( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImageRobustnessFeaturesEXT;
+    void *                                    pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32              robustImageAccess = {};
+  };
+  static_assert( sizeof( PhysicalDeviceImageRobustnessFeaturesEXT ) ==
+                   sizeof( VkPhysicalDeviceImageRobustnessFeaturesEXT ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceImageRobustnessFeaturesEXT>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceImageRobustnessFeaturesEXT>
+  {
+    using Type = PhysicalDeviceImageRobustnessFeaturesEXT;
+  };
+
   struct PhysicalDeviceImageViewImageFormatInfoEXT
   {
     static const bool                                  allowDuplicate = false;
@@ -66621,6 +66720,228 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
   };
 
+  struct PhysicalDeviceShaderAtomicFloatFeaturesEXT
+  {
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloatFeaturesEXT(
+      VULKAN_HPP_NAMESPACE::Bool32 shaderBufferFloat32Atomics_   = {},
+      VULKAN_HPP_NAMESPACE::Bool32 shaderBufferFloat32AtomicAdd_ = {},
+      VULKAN_HPP_NAMESPACE::Bool32 shaderBufferFloat64Atomics_   = {},
+      VULKAN_HPP_NAMESPACE::Bool32 shaderBufferFloat64AtomicAdd_ = {},
+      VULKAN_HPP_NAMESPACE::Bool32 shaderSharedFloat32Atomics_   = {},
+      VULKAN_HPP_NAMESPACE::Bool32 shaderSharedFloat32AtomicAdd_ = {},
+      VULKAN_HPP_NAMESPACE::Bool32 shaderSharedFloat64Atomics_   = {},
+      VULKAN_HPP_NAMESPACE::Bool32 shaderSharedFloat64AtomicAdd_ = {},
+      VULKAN_HPP_NAMESPACE::Bool32 shaderImageFloat32Atomics_    = {},
+      VULKAN_HPP_NAMESPACE::Bool32 shaderImageFloat32AtomicAdd_  = {},
+      VULKAN_HPP_NAMESPACE::Bool32 sparseImageFloat32Atomics_    = {},
+      VULKAN_HPP_NAMESPACE::Bool32 sparseImageFloat32AtomicAdd_  = {} ) VULKAN_HPP_NOEXCEPT
+      : shaderBufferFloat32Atomics( shaderBufferFloat32Atomics_ )
+      , shaderBufferFloat32AtomicAdd( shaderBufferFloat32AtomicAdd_ )
+      , shaderBufferFloat64Atomics( shaderBufferFloat64Atomics_ )
+      , shaderBufferFloat64AtomicAdd( shaderBufferFloat64AtomicAdd_ )
+      , shaderSharedFloat32Atomics( shaderSharedFloat32Atomics_ )
+      , shaderSharedFloat32AtomicAdd( shaderSharedFloat32AtomicAdd_ )
+      , shaderSharedFloat64Atomics( shaderSharedFloat64Atomics_ )
+      , shaderSharedFloat64AtomicAdd( shaderSharedFloat64AtomicAdd_ )
+      , shaderImageFloat32Atomics( shaderImageFloat32Atomics_ )
+      , shaderImageFloat32AtomicAdd( shaderImageFloat32AtomicAdd_ )
+      , sparseImageFloat32Atomics( sparseImageFloat32Atomics_ )
+      , sparseImageFloat32AtomicAdd( sparseImageFloat32AtomicAdd_ )
+    {}
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs )
+      VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+#endif  // !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      operator=( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const *>( &rhs );
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      operator=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext                        = rhs.pNext;
+      shaderBufferFloat32Atomics   = rhs.shaderBufferFloat32Atomics;
+      shaderBufferFloat32AtomicAdd = rhs.shaderBufferFloat32AtomicAdd;
+      shaderBufferFloat64Atomics   = rhs.shaderBufferFloat64Atomics;
+      shaderBufferFloat64AtomicAdd = rhs.shaderBufferFloat64AtomicAdd;
+      shaderSharedFloat32Atomics   = rhs.shaderSharedFloat32Atomics;
+      shaderSharedFloat32AtomicAdd = rhs.shaderSharedFloat32AtomicAdd;
+      shaderSharedFloat64Atomics   = rhs.shaderSharedFloat64Atomics;
+      shaderSharedFloat64AtomicAdd = rhs.shaderSharedFloat64AtomicAdd;
+      shaderImageFloat32Atomics    = rhs.shaderImageFloat32Atomics;
+      shaderImageFloat32AtomicAdd  = rhs.shaderImageFloat32AtomicAdd;
+      sparseImageFloat32Atomics    = rhs.sparseImageFloat32Atomics;
+      sparseImageFloat32AtomicAdd  = rhs.sparseImageFloat32AtomicAdd;
+
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderBufferFloat32Atomics( VULKAN_HPP_NAMESPACE::Bool32 shaderBufferFloat32Atomics_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderBufferFloat32Atomics = shaderBufferFloat32Atomics_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderBufferFloat32AtomicAdd( VULKAN_HPP_NAMESPACE::Bool32 shaderBufferFloat32AtomicAdd_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderBufferFloat32AtomicAdd = shaderBufferFloat32AtomicAdd_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderBufferFloat64Atomics( VULKAN_HPP_NAMESPACE::Bool32 shaderBufferFloat64Atomics_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderBufferFloat64Atomics = shaderBufferFloat64Atomics_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderBufferFloat64AtomicAdd( VULKAN_HPP_NAMESPACE::Bool32 shaderBufferFloat64AtomicAdd_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderBufferFloat64AtomicAdd = shaderBufferFloat64AtomicAdd_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderSharedFloat32Atomics( VULKAN_HPP_NAMESPACE::Bool32 shaderSharedFloat32Atomics_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderSharedFloat32Atomics = shaderSharedFloat32Atomics_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderSharedFloat32AtomicAdd( VULKAN_HPP_NAMESPACE::Bool32 shaderSharedFloat32AtomicAdd_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderSharedFloat32AtomicAdd = shaderSharedFloat32AtomicAdd_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderSharedFloat64Atomics( VULKAN_HPP_NAMESPACE::Bool32 shaderSharedFloat64Atomics_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderSharedFloat64Atomics = shaderSharedFloat64Atomics_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderSharedFloat64AtomicAdd( VULKAN_HPP_NAMESPACE::Bool32 shaderSharedFloat64AtomicAdd_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderSharedFloat64AtomicAdd = shaderSharedFloat64AtomicAdd_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderImageFloat32Atomics( VULKAN_HPP_NAMESPACE::Bool32 shaderImageFloat32Atomics_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderImageFloat32Atomics = shaderImageFloat32Atomics_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setShaderImageFloat32AtomicAdd( VULKAN_HPP_NAMESPACE::Bool32 shaderImageFloat32AtomicAdd_ ) VULKAN_HPP_NOEXCEPT
+    {
+      shaderImageFloat32AtomicAdd = shaderImageFloat32AtomicAdd_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setSparseImageFloat32Atomics( VULKAN_HPP_NAMESPACE::Bool32 sparseImageFloat32Atomics_ ) VULKAN_HPP_NOEXCEPT
+    {
+      sparseImageFloat32Atomics = sparseImageFloat32Atomics_;
+      return *this;
+    }
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT &
+      setSparseImageFloat32AtomicAdd( VULKAN_HPP_NAMESPACE::Bool32 sparseImageFloat32AtomicAdd_ ) VULKAN_HPP_NOEXCEPT
+    {
+      sparseImageFloat32AtomicAdd = sparseImageFloat32AtomicAdd_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>( this );
+    }
+
+    operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderBufferFloat32Atomics == rhs.shaderBufferFloat32Atomics ) &&
+             ( shaderBufferFloat32AtomicAdd == rhs.shaderBufferFloat32AtomicAdd ) &&
+             ( shaderBufferFloat64Atomics == rhs.shaderBufferFloat64Atomics ) &&
+             ( shaderBufferFloat64AtomicAdd == rhs.shaderBufferFloat64AtomicAdd ) &&
+             ( shaderSharedFloat32Atomics == rhs.shaderSharedFloat32Atomics ) &&
+             ( shaderSharedFloat32AtomicAdd == rhs.shaderSharedFloat32AtomicAdd ) &&
+             ( shaderSharedFloat64Atomics == rhs.shaderSharedFloat64Atomics ) &&
+             ( shaderSharedFloat64AtomicAdd == rhs.shaderSharedFloat64AtomicAdd ) &&
+             ( shaderImageFloat32Atomics == rhs.shaderImageFloat32Atomics ) &&
+             ( shaderImageFloat32AtomicAdd == rhs.shaderImageFloat32AtomicAdd ) &&
+             ( sparseImageFloat32Atomics == rhs.sparseImageFloat32Atomics ) &&
+             ( sparseImageFloat32AtomicAdd == rhs.sparseImageFloat32AtomicAdd );
+    }
+
+    bool operator!=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT;
+    void *                                    pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderBufferFloat32Atomics   = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderBufferFloat32AtomicAdd = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderBufferFloat64Atomics   = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderBufferFloat64AtomicAdd = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderSharedFloat32Atomics   = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderSharedFloat32AtomicAdd = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderSharedFloat64Atomics   = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderSharedFloat64AtomicAdd = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderImageFloat32Atomics    = {};
+    VULKAN_HPP_NAMESPACE::Bool32              shaderImageFloat32AtomicAdd  = {};
+    VULKAN_HPP_NAMESPACE::Bool32              sparseImageFloat32Atomics    = {};
+    VULKAN_HPP_NAMESPACE::Bool32              sparseImageFloat32AtomicAdd  = {};
+  };
+  static_assert( sizeof( PhysicalDeviceShaderAtomicFloatFeaturesEXT ) ==
+                   sizeof( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceShaderAtomicFloatFeaturesEXT>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT>
+  {
+    using Type = PhysicalDeviceShaderAtomicFloatFeaturesEXT;
+  };
+
   struct PhysicalDeviceShaderAtomicInt64Features
   {
     static const bool                                  allowDuplicate = false;
@@ -102387,6 +102708,22 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct StructExtends<PhysicalDeviceImageRobustnessFeaturesEXT, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceImageRobustnessFeaturesEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<PhysicalDeviceImageViewImageFormatInfoEXT, PhysicalDeviceImageFormatInfo2>
   {
     enum
@@ -102823,6 +103160,22 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceFeatures2>
   {
     enum