Merge pull request #583 from asuessenbach/139

Update to VK_HEADER_VERSION 139.

Vulkan-Headers

@@ -1 +1 @@
-Subproject commit e01f13e1f777cf592ebd1a5f4836d4cd10ed85f6
+Subproject commit 4c19ae6b95e44c821d5306adf94842defa57ba21

vulkan/vulkan.hpp

@@ -82,7 +82,7 @@
 #  include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION == 137, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 139, "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
@@ -9356,8 +9356,10 @@ namespace VULKAN_HPP_NAMESPACE
       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT,
     eCommandBufferInheritanceRenderPassTransformInfoQCOM =
       VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
-    eRenderPassTransformBeginInfoQCOM = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
+    eRenderPassTransformBeginInfoQCOM       = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
-    ePipelineLibraryCreateInfoKHR     = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR,
+    ePhysicalDeviceRobustness2FeaturesEXT   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
+    ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
+    ePipelineLibraryCreateInfoKHR           = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR,
     ePhysicalDevicePipelineCreationCacheControlFeaturesEXT =
       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT,
     ePhysicalDeviceDiagnosticsConfigFeaturesNV  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
@@ -10023,6 +10025,8 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM:
         return "CommandBufferInheritanceRenderPassTransformInfoQCOM";
       case StructureType::eRenderPassTransformBeginInfoQCOM: return "RenderPassTransformBeginInfoQCOM";
+      case StructureType::ePhysicalDeviceRobustness2FeaturesEXT: return "PhysicalDeviceRobustness2FeaturesEXT";
+      case StructureType::ePhysicalDeviceRobustness2PropertiesEXT: return "PhysicalDeviceRobustness2PropertiesEXT";
       case StructureType::ePipelineLibraryCreateInfoKHR: return "PipelineLibraryCreateInfoKHR";
       case StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT:
         return "PhysicalDevicePipelineCreationCacheControlFeaturesEXT";
@@ -10082,7 +10086,9 @@ namespace VULKAN_HPP_NAMESPACE
   enum class SubpassDescriptionFlagBits : VkSubpassDescriptionFlags
   {
     ePerViewAttributesNVX    = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
-    ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX
+    ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX,
+    eFragmentRegionQCOM      = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM,
+    eShaderResolveQCOM       = VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM
   };
 
   VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlagBits value )
@@ -10091,6 +10097,8 @@ namespace VULKAN_HPP_NAMESPACE
     {
       case SubpassDescriptionFlagBits::ePerViewAttributesNVX: return "PerViewAttributesNVX";
       case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX: return "PerViewPositionXOnlyNVX";
+      case SubpassDescriptionFlagBits::eFragmentRegionQCOM: return "FragmentRegionQCOM";
+      case SubpassDescriptionFlagBits::eShaderResolveQCOM: return "ShaderResolveQCOM";
       default: return "invalid";
     }
   }
@@ -14912,7 +14920,9 @@ namespace VULKAN_HPP_NAMESPACE
     enum : VkFlags
     {
       allFlags = VkFlags( SubpassDescriptionFlagBits::ePerViewAttributesNVX ) |
-                 VkFlags( SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX )
+                 VkFlags( SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX ) |
+                 VkFlags( SubpassDescriptionFlagBits::eFragmentRegionQCOM ) |
+                 VkFlags( SubpassDescriptionFlagBits::eShaderResolveQCOM )
     };
   };
 
@@ -14950,6 +14960,10 @@ namespace VULKAN_HPP_NAMESPACE
       result += "PerViewAttributesNVX | ";
     if ( value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX )
       result += "PerViewPositionXOnlyNVX | ";
+    if ( value & SubpassDescriptionFlagBits::eFragmentRegionQCOM )
+      result += "FragmentRegionQCOM | ";
+    if ( value & SubpassDescriptionFlagBits::eShaderResolveQCOM )
+      result += "ShaderResolveQCOM | ";
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
@@ -16409,6 +16423,8 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
   struct PhysicalDeviceRayTracingPropertiesNV;
   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
+  struct PhysicalDeviceRobustness2FeaturesEXT;
+  struct PhysicalDeviceRobustness2PropertiesEXT;
   struct PhysicalDeviceSampleLocationsPropertiesEXT;
   struct PhysicalDeviceSamplerFilterMinmaxProperties;
   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
@@ -61170,6 +61186,189 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
   };
 
+  struct PhysicalDeviceRobustness2FeaturesEXT
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceRobustness2FeaturesEXT;
+
+    VULKAN_HPP_CONSTEXPR
+      PhysicalDeviceRobustness2FeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ = {},
+                                            VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_  = {},
+                                            VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_      = {} ) VULKAN_HPP_NOEXCEPT
+      : robustBufferAccess2( robustBufferAccess2_ )
+      , robustImageAccess2( robustImageAccess2_ )
+      , nullDescriptor( nullDescriptor_ )
+    {}
+
+    PhysicalDeviceRobustness2FeaturesEXT &
+      operator=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext,
+              &rhs.pNext,
+              sizeof( PhysicalDeviceRobustness2FeaturesEXT ) -
+                offsetof( PhysicalDeviceRobustness2FeaturesEXT, pNext ) );
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT &
+      operator=( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const *>( &rhs );
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT &
+      setRobustBufferAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ ) VULKAN_HPP_NOEXCEPT
+    {
+      robustBufferAccess2 = robustBufferAccess2_;
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT &
+      setRobustImageAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ ) VULKAN_HPP_NOEXCEPT
+    {
+      robustImageAccess2 = robustImageAccess2_;
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2FeaturesEXT &
+      setNullDescriptor( VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ ) VULKAN_HPP_NOEXCEPT
+    {
+      nullDescriptor = nullDescriptor_;
+      return *this;
+    }
+
+    operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
+    }
+
+    operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) &&
+             ( robustImageAccess2 == rhs.robustImageAccess2 ) && ( nullDescriptor == rhs.nullDescriptor );
+    }
+
+    bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2FeaturesEXT;
+    void *                                    pNext = {};
+    VULKAN_HPP_NAMESPACE::Bool32              robustBufferAccess2 = {};
+    VULKAN_HPP_NAMESPACE::Bool32              robustImageAccess2  = {};
+    VULKAN_HPP_NAMESPACE::Bool32              nullDescriptor      = {};
+  };
+  static_assert( sizeof( PhysicalDeviceRobustness2FeaturesEXT ) == sizeof( VkPhysicalDeviceRobustness2FeaturesEXT ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceRobustness2FeaturesEXT>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2FeaturesEXT>
+  {
+    using Type = PhysicalDeviceRobustness2FeaturesEXT;
+  };
+
+  struct PhysicalDeviceRobustness2PropertiesEXT
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
+      StructureType::ePhysicalDeviceRobustness2PropertiesEXT;
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesEXT(
+      VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment_ = {},
+      VULKAN_HPP_NAMESPACE::DeviceSize robustUniformBufferAccessSizeAlignment_ = {} ) VULKAN_HPP_NOEXCEPT
+      : robustStorageBufferAccessSizeAlignment( robustStorageBufferAccessSizeAlignment_ )
+      , robustUniformBufferAccessSizeAlignment( robustUniformBufferAccessSizeAlignment_ )
+    {}
+
+    PhysicalDeviceRobustness2PropertiesEXT &
+      operator=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      memcpy( &pNext,
+              &rhs.pNext,
+              sizeof( PhysicalDeviceRobustness2PropertiesEXT ) -
+                offsetof( PhysicalDeviceRobustness2PropertiesEXT, pNext ) );
+      return *this;
+    }
+
+    PhysicalDeviceRobustness2PropertiesEXT( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = rhs;
+    }
+
+    PhysicalDeviceRobustness2PropertiesEXT &
+      operator=( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const *>( &rhs );
+      return *this;
+    }
+
+    operator VkPhysicalDeviceRobustness2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
+    }
+
+    operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) &&
+             ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment );
+    }
+
+    bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2PropertiesEXT;
+    void *                                    pNext = {};
+    VULKAN_HPP_NAMESPACE::DeviceSize          robustStorageBufferAccessSizeAlignment = {};
+    VULKAN_HPP_NAMESPACE::DeviceSize          robustUniformBufferAccessSizeAlignment = {};
+  };
+  static_assert( sizeof( PhysicalDeviceRobustness2PropertiesEXT ) == sizeof( VkPhysicalDeviceRobustness2PropertiesEXT ),
+                 "struct and wrapper have different size!" );
+  static_assert( std::is_standard_layout<PhysicalDeviceRobustness2PropertiesEXT>::value,
+                 "struct wrapper is not a standard layout!" );
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2PropertiesEXT>
+  {
+    using Type = PhysicalDeviceRobustness2PropertiesEXT;
+  };
+
   struct PhysicalDeviceSampleLocationsPropertiesEXT
   {
     static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
@@ -94444,6 +94643,30 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceRobustness2FeaturesEXT>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceRobustness2FeaturesEXT>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceRobustness2PropertiesEXT>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSampleLocationsPropertiesEXT>
   {
     enum