Update for Vulkan-Docs 1.3.300

include/vulkan/vulkan.cppm

@@ -2605,6 +2605,10 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::EXTDepthClampControlExtensionName;
   using VULKAN_HPP_NAMESPACE::EXTDepthClampControlSpecVersion;
 
+  //=== VK_NV_cooperative_matrix2 ===
+  using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2ExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2SpecVersion;
+
   //========================
   //=== CONSTEXPR VALUEs ===
   //========================
@@ -4529,6 +4533,11 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT;
   using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT;
 
+  //=== VK_NV_cooperative_matrix2 ===
+  using VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV;
+
   //===============
   //=== HANDLEs ===
   //===============

include/vulkan/vulkan.hpp

@@ -63,7 +63,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <span>
 #endif
 
-static_assert( VK_HEADER_VERSION == 299, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 300, "Wrong VK_HEADER_VERSION!" );
 
 // <tuple> includes <sys/sysmacros.h> through some other header
 // this results in major(x) being resolved to gnu_dev_major(x)
@@ -6000,6 +6000,14 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return ::vkUpdateIndirectExecutionSetShaderEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites );
     }
+
+    //=== VK_NV_cooperative_matrix2 ===
+
+    VkResult vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
+      VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ::vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( physicalDevice, pPropertyCount, pProperties );
+    }
   };
 
   inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
@@ -8675,6 +8683,10 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlExtensionName = VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlSpecVersion   = VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION;
 
+  //=== VK_NV_cooperative_matrix2 ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2ExtensionName = VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2SpecVersion   = VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION;
+
 }  // namespace VULKAN_HPP_NAMESPACE
 
 // clang-format off
@@ -17060,6 +17072,34 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_NV_cooperative_matrix2 ===
+  template <>
+  struct StructExtends<PhysicalDeviceCooperativeMatrix2FeaturesNV, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceCooperativeMatrix2FeaturesNV, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceCooperativeMatrix2PropertiesNV, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
 #endif  // VULKAN_HPP_DISABLE_ENHANCED_MODE
 
 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
@@ -18322,6 +18362,9 @@ namespace VULKAN_HPP_NAMESPACE
     PFN_vkUpdateIndirectExecutionSetPipelineEXT     vkUpdateIndirectExecutionSetPipelineEXT     = 0;
     PFN_vkUpdateIndirectExecutionSetShaderEXT       vkUpdateIndirectExecutionSetShaderEXT       = 0;
 
+    //=== VK_NV_cooperative_matrix2 ===
+    PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0;
+
   public:
     DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT                                    = default;
     DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
@@ -19752,6 +19795,10 @@ namespace VULKAN_HPP_NAMESPACE
         PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetPipelineEXT" ) );
       vkUpdateIndirectExecutionSetShaderEXT =
         PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetShaderEXT" ) );
+
+      //=== VK_NV_cooperative_matrix2 ===
+      vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
+        vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) );
     }
 
     void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT

include/vulkan/vulkan_core.h

@@ -69,7 +69,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 299
+#define VK_HEADER_VERSION 300
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@@ -1163,6 +1163,9 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000,
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV = 1000593000,
+    VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV = 1000593001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
   // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a deprecated alias
@@ -19898,6 +19901,55 @@ typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT {
 
 
 
+// VK_NV_cooperative_matrix2 is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_cooperative_matrix2 1
+#define VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION 1
+#define VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME "VK_NV_cooperative_matrix2"
+typedef struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV {
+    VkStructureType       sType;
+    void*                 pNext;
+    uint32_t              MGranularity;
+    uint32_t              NGranularity;
+    uint32_t              KGranularity;
+    VkComponentTypeKHR    AType;
+    VkComponentTypeKHR    BType;
+    VkComponentTypeKHR    CType;
+    VkComponentTypeKHR    ResultType;
+    VkBool32              saturatingAccumulation;
+    VkScopeKHR            scope;
+    uint32_t              workgroupInvocations;
+} VkCooperativeMatrixFlexibleDimensionsPropertiesNV;
+
+typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           cooperativeMatrixWorkgroupScope;
+    VkBool32           cooperativeMatrixFlexibleDimensions;
+    VkBool32           cooperativeMatrixReductions;
+    VkBool32           cooperativeMatrixConversions;
+    VkBool32           cooperativeMatrixPerElementOperations;
+    VkBool32           cooperativeMatrixTensorAddressing;
+    VkBool32           cooperativeMatrixBlockLoads;
+} VkPhysicalDeviceCooperativeMatrix2FeaturesNV;
+
+typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
+    uint32_t           cooperativeMatrixFlexibleDimensionsMaxDimension;
+    uint32_t           cooperativeMatrixWorkgroupScopeReservedSharedMemory;
+} VkPhysicalDeviceCooperativeMatrix2PropertiesNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties);
+#endif
+
+
 // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_acceleration_structure 1
 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13

include/vulkan/vulkan_enums.hpp

@@ -1467,7 +1467,10 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceImageAlignmentControlPropertiesMESA         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA,
     eImageAlignmentControlCreateInfoMESA                       = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA,
     ePhysicalDeviceDepthClampControlFeaturesEXT                = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT,
-    ePipelineViewportDepthClampControlCreateInfoEXT            = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT
+    ePipelineViewportDepthClampControlCreateInfoEXT            = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT,
+    ePhysicalDeviceCooperativeMatrix2FeaturesNV                = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV,
+    eCooperativeMatrixFlexibleDimensionsPropertiesNV           = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV,
+    ePhysicalDeviceCooperativeMatrix2PropertiesNV              = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV
   };
 
   enum class PipelineCacheHeaderVersion

include/vulkan/vulkan_extension_inspection.hpp

@@ -453,7 +453,8 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_NV_ray_tracing_validation",
       "VK_EXT_device_generated_commands",
       "VK_MESA_image_alignment_control",
-      "VK_EXT_depth_clamp_control"
+      "VK_EXT_depth_clamp_control",
+      "VK_NV_cooperative_matrix2"
     };
     return deviceExtensions;
   }
@@ -2360,7 +2361,12 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
-          { "VK_VERSION_1_1", { {} } } } }
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_cooperative_matrix2",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_cooperative_matrix",
+            } } } } }
     };
     auto depIt = dependencies.find( extension );
     return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
@@ -3139,7 +3145,7 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
            ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
            ( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_MESA_image_alignment_control" ) ||
-           ( extension == "VK_EXT_depth_clamp_control" );
+           ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_NV_cooperative_matrix2" );
   }
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

include/vulkan/vulkan_hash.hpp

@@ -2527,6 +2527,29 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV>
+  {
+    std::size_t operator()(
+      VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV const & cooperativeMatrixFlexibleDimensionsPropertiesNV ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.MGranularity );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.NGranularity );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.KGranularity );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.AType );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.BType );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.CType );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.ResultType );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.saturatingAccumulation );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.scope );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.workgroupInvocations );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>
   {
@@ -8091,6 +8114,42 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV const & physicalDeviceCooperativeMatrix2FeaturesNV ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixWorkgroupScope );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixFlexibleDimensions );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixReductions );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixConversions );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixPerElementOperations );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixTensorAddressing );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixBlockLoads );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV const & physicalDeviceCooperativeMatrix2PropertiesNV ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixFlexibleDimensionsMaxDimension );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixWorkgroupScopeReservedSharedMemory );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR>
   {

include/vulkan/vulkan_raii.hpp

@@ -376,6 +376,10 @@ namespace VULKAN_HPP_NAMESPACE
         vkGetPhysicalDeviceCalibrateableTimeDomainsKHR =
           PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) );
 
+        //=== VK_NV_cooperative_matrix2 ===
+        vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
+          vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) );
+
         vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
       }
 
@@ -653,6 +657,9 @@ namespace VULKAN_HPP_NAMESPACE
       //=== VK_KHR_calibrated_timestamps ===
       PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0;
 
+      //=== VK_NV_cooperative_matrix2 ===
+      PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0;
+
       PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0;
     };
 
@@ -3539,6 +3546,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> getCalibrateableTimeDomainsKHR() const;
 
+      //=== VK_NV_cooperative_matrix2 ===
+
+      VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV>
+                           getCooperativeMatrixFlexibleDimensionsPropertiesNV() const;
+
     private:
       VULKAN_HPP_NAMESPACE::PhysicalDevice                                        m_physicalDevice = {};
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher     = nullptr;
@@ -13548,6 +13560,9 @@ namespace VULKAN_HPP_NAMESPACE
                                     VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
       VULKAN_HPP_RAII_CREATE_NOEXCEPT
     {
+      VULKAN_HPP_ASSERT(
+        createInfo.flags & vk::DescriptorPoolCreateFlagBits::eFreeDescriptorSet &&
+        "createInfo.flags need to have vk::DescriptorPoolCreateFlagBits::eFreeDesriptors set in order to allow destruction of VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet which requires to return individual allocations to the pool" );
       VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool;
       VULKAN_HPP_NAMESPACE::Result         result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDescriptorPool(
         static_cast<VkDevice>( m_device ),
@@ -23687,6 +23702,39 @@ namespace VULKAN_HPP_NAMESPACE
                                                               reinterpret_cast<const VkWriteIndirectExecutionSetShaderEXT *>( executionSetWrites.data() ) );
     }
 
+    //=== VK_NV_cooperative_matrix2 ===
+
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV>
+                                           PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV() const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV &&
+                         "Function <vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV> requires <VK_NV_cooperative_matrix2>" );
+
+      std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV> properties;
+      uint32_t                                                                           propertyCount;
+      VULKAN_HPP_NAMESPACE::Result                                                       result;
+      do
+      {
+        result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
+        if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
+        {
+          properties.resize( propertyCount );
+          result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            &propertyCount,
+            reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV *>( properties.data() ) ) );
+        }
+      } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
+      VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV" );
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      if ( propertyCount < properties.size() )
+      {
+        properties.resize( propertyCount );
+      }
+      return properties;
+    }
+
     //====================
     //=== RAII Helpers ===
     //====================

include/vulkan/vulkan_static_assertions.hpp

@@ -7984,4 +7984,29 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DepthCla
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DepthClampRangeEXT>::value,
                           "DepthClampRangeEXT is not nothrow_move_constructible!" );
 
+//=== VK_NV_cooperative_matrix2 ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV ) ==
+                            sizeof( VkCooperativeMatrixFlexibleDimensionsPropertiesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV>::value,
+                          "CooperativeMatrixFlexibleDimensionsPropertiesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrix2FeaturesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV>::value,
+                          "PhysicalDeviceCooperativeMatrix2FeaturesNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV ) ==
+                            sizeof( VkPhysicalDeviceCooperativeMatrix2PropertiesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV>::value,
+                          "PhysicalDeviceCooperativeMatrix2PropertiesNV is not nothrow_move_constructible!" );
+
 #endif

include/vulkan/vulkan_structs.hpp

@@ -16892,6 +16892,133 @@ namespace VULKAN_HPP_NAMESPACE
 
   using ConformanceVersionKHR = ConformanceVersion;
 
+  struct CooperativeMatrixFlexibleDimensionsPropertiesNV
+  {
+    using NativeType = VkCooperativeMatrixFlexibleDimensionsPropertiesNV;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR
+      CooperativeMatrixFlexibleDimensionsPropertiesNV( uint32_t                               MGranularity_ = {},
+                                                       uint32_t                               NGranularity_ = {},
+                                                       uint32_t                               KGranularity_ = {},
+                                                       VULKAN_HPP_NAMESPACE::ComponentTypeKHR AType_        = VULKAN_HPP_NAMESPACE::ComponentTypeKHR::eFloat16,
+                                                       VULKAN_HPP_NAMESPACE::ComponentTypeKHR BType_        = VULKAN_HPP_NAMESPACE::ComponentTypeKHR::eFloat16,
+                                                       VULKAN_HPP_NAMESPACE::ComponentTypeKHR CType_        = VULKAN_HPP_NAMESPACE::ComponentTypeKHR::eFloat16,
+                                                       VULKAN_HPP_NAMESPACE::ComponentTypeKHR ResultType_   = VULKAN_HPP_NAMESPACE::ComponentTypeKHR::eFloat16,
+                                                       VULKAN_HPP_NAMESPACE::Bool32           saturatingAccumulation_ = {},
+                                                       VULKAN_HPP_NAMESPACE::ScopeKHR         scope_                  = VULKAN_HPP_NAMESPACE::ScopeKHR::eDevice,
+                                                       uint32_t                               workgroupInvocations_   = {},
+                                                       void *                                 pNext_                  = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , MGranularity{ MGranularity_ }
+      , NGranularity{ NGranularity_ }
+      , KGranularity{ KGranularity_ }
+      , AType{ AType_ }
+      , BType{ BType_ }
+      , CType{ CType_ }
+      , ResultType{ ResultType_ }
+      , saturatingAccumulation{ saturatingAccumulation_ }
+      , scope{ scope_ }
+      , workgroupInvocations{ workgroupInvocations_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR
+      CooperativeMatrixFlexibleDimensionsPropertiesNV( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    CooperativeMatrixFlexibleDimensionsPropertiesNV( VkCooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+      : CooperativeMatrixFlexibleDimensionsPropertiesNV( *reinterpret_cast<CooperativeMatrixFlexibleDimensionsPropertiesNV const *>( &rhs ) )
+    {
+    }
+
+    CooperativeMatrixFlexibleDimensionsPropertiesNV & operator=( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    CooperativeMatrixFlexibleDimensionsPropertiesNV & operator=( VkCooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV const *>( &rhs );
+      return *this;
+    }
+
+    operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *>( this );
+    }
+
+    operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               VULKAN_HPP_NAMESPACE::ComponentTypeKHR const &,
+               VULKAN_HPP_NAMESPACE::ComponentTypeKHR const &,
+               VULKAN_HPP_NAMESPACE::ComponentTypeKHR const &,
+               VULKAN_HPP_NAMESPACE::ComponentTypeKHR const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::ScopeKHR const &,
+               uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie(
+        sType, pNext, MGranularity, NGranularity, KGranularity, AType, BType, CType, ResultType, saturatingAccumulation, scope, workgroupInvocations );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( CooperativeMatrixFlexibleDimensionsPropertiesNV const & ) const = default;
+#else
+    bool operator==( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MGranularity == rhs.MGranularity ) && ( NGranularity == rhs.NGranularity ) &&
+             ( KGranularity == rhs.KGranularity ) && ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) &&
+             ( ResultType == rhs.ResultType ) && ( saturatingAccumulation == rhs.saturatingAccumulation ) && ( scope == rhs.scope ) &&
+             ( workgroupInvocations == rhs.workgroupInvocations );
+#  endif
+    }
+
+    bool operator!=( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType    sType                  = StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV;
+    void *                                 pNext                  = {};
+    uint32_t                               MGranularity           = {};
+    uint32_t                               NGranularity           = {};
+    uint32_t                               KGranularity           = {};
+    VULKAN_HPP_NAMESPACE::ComponentTypeKHR AType                  = VULKAN_HPP_NAMESPACE::ComponentTypeKHR::eFloat16;
+    VULKAN_HPP_NAMESPACE::ComponentTypeKHR BType                  = VULKAN_HPP_NAMESPACE::ComponentTypeKHR::eFloat16;
+    VULKAN_HPP_NAMESPACE::ComponentTypeKHR CType                  = VULKAN_HPP_NAMESPACE::ComponentTypeKHR::eFloat16;
+    VULKAN_HPP_NAMESPACE::ComponentTypeKHR ResultType             = VULKAN_HPP_NAMESPACE::ComponentTypeKHR::eFloat16;
+    VULKAN_HPP_NAMESPACE::Bool32           saturatingAccumulation = {};
+    VULKAN_HPP_NAMESPACE::ScopeKHR         scope                  = VULKAN_HPP_NAMESPACE::ScopeKHR::eDevice;
+    uint32_t                               workgroupInvocations   = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV>
+  {
+    using Type = CooperativeMatrixFlexibleDimensionsPropertiesNV;
+  };
+
   struct CooperativeMatrixPropertiesKHR
   {
     using NativeType = VkCooperativeMatrixPropertiesKHR;
@@ -61625,6 +61752,281 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT;
   };
 
+  struct PhysicalDeviceCooperativeMatrix2FeaturesNV
+  {
+    using NativeType = VkPhysicalDeviceCooperativeMatrix2FeaturesNV;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2FeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixWorkgroupScope_       = {},
+                                                                     VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixFlexibleDimensions_   = {},
+                                                                     VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixReductions_           = {},
+                                                                     VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixConversions_          = {},
+                                                                     VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixPerElementOperations_ = {},
+                                                                     VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixTensorAddressing_     = {},
+                                                                     VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixBlockLoads_           = {},
+                                                                     void *                       pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , cooperativeMatrixWorkgroupScope{ cooperativeMatrixWorkgroupScope_ }
+      , cooperativeMatrixFlexibleDimensions{ cooperativeMatrixFlexibleDimensions_ }
+      , cooperativeMatrixReductions{ cooperativeMatrixReductions_ }
+      , cooperativeMatrixConversions{ cooperativeMatrixConversions_ }
+      , cooperativeMatrixPerElementOperations{ cooperativeMatrixPerElementOperations_ }
+      , cooperativeMatrixTensorAddressing{ cooperativeMatrixTensorAddressing_ }
+      , cooperativeMatrixBlockLoads{ cooperativeMatrixBlockLoads_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2FeaturesNV( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceCooperativeMatrix2FeaturesNV( VkPhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceCooperativeMatrix2FeaturesNV( *reinterpret_cast<PhysicalDeviceCooperativeMatrix2FeaturesNV const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceCooperativeMatrix2FeaturesNV & operator=( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceCooperativeMatrix2FeaturesNV & operator=( VkPhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV &
+      setCooperativeMatrixWorkgroupScope( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixWorkgroupScope_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixWorkgroupScope = cooperativeMatrixWorkgroupScope_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV &
+      setCooperativeMatrixFlexibleDimensions( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixFlexibleDimensions_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixFlexibleDimensions = cooperativeMatrixFlexibleDimensions_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV &
+      setCooperativeMatrixReductions( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixReductions_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixReductions = cooperativeMatrixReductions_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV &
+      setCooperativeMatrixConversions( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixConversions_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixConversions = cooperativeMatrixConversions_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV &
+      setCooperativeMatrixPerElementOperations( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixPerElementOperations_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixPerElementOperations = cooperativeMatrixPerElementOperations_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV &
+      setCooperativeMatrixTensorAddressing( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixTensorAddressing_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixTensorAddressing = cooperativeMatrixTensorAddressing_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV &
+      setCooperativeMatrixBlockLoads( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixBlockLoads_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixBlockLoads = cooperativeMatrixBlockLoads_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
+
+    operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>( this );
+    }
+
+    operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
+               void * const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &,
+               VULKAN_HPP_NAMESPACE::Bool32 const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       cooperativeMatrixWorkgroupScope,
+                       cooperativeMatrixFlexibleDimensions,
+                       cooperativeMatrixReductions,
+                       cooperativeMatrixConversions,
+                       cooperativeMatrixPerElementOperations,
+                       cooperativeMatrixTensorAddressing,
+                       cooperativeMatrixBlockLoads );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceCooperativeMatrix2FeaturesNV const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrixWorkgroupScope == rhs.cooperativeMatrixWorkgroupScope ) &&
+             ( cooperativeMatrixFlexibleDimensions == rhs.cooperativeMatrixFlexibleDimensions ) &&
+             ( cooperativeMatrixReductions == rhs.cooperativeMatrixReductions ) && ( cooperativeMatrixConversions == rhs.cooperativeMatrixConversions ) &&
+             ( cooperativeMatrixPerElementOperations == rhs.cooperativeMatrixPerElementOperations ) &&
+             ( cooperativeMatrixTensorAddressing == rhs.cooperativeMatrixTensorAddressing ) &&
+             ( cooperativeMatrixBlockLoads == rhs.cooperativeMatrixBlockLoads );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                                 = StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV;
+    void *                              pNext                                 = {};
+    VULKAN_HPP_NAMESPACE::Bool32        cooperativeMatrixWorkgroupScope       = {};
+    VULKAN_HPP_NAMESPACE::Bool32        cooperativeMatrixFlexibleDimensions   = {};
+    VULKAN_HPP_NAMESPACE::Bool32        cooperativeMatrixReductions           = {};
+    VULKAN_HPP_NAMESPACE::Bool32        cooperativeMatrixConversions          = {};
+    VULKAN_HPP_NAMESPACE::Bool32        cooperativeMatrixPerElementOperations = {};
+    VULKAN_HPP_NAMESPACE::Bool32        cooperativeMatrixTensorAddressing     = {};
+    VULKAN_HPP_NAMESPACE::Bool32        cooperativeMatrixBlockLoads           = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV>
+  {
+    using Type = PhysicalDeviceCooperativeMatrix2FeaturesNV;
+  };
+
+  struct PhysicalDeviceCooperativeMatrix2PropertiesNV
+  {
+    using NativeType = VkPhysicalDeviceCooperativeMatrix2PropertiesNV;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV;
+
+#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2PropertiesNV( uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize_     = {},
+                                                                       uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension_     = {},
+                                                                       uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory_ = {},
+                                                                       void *   pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , cooperativeMatrixWorkgroupScopeMaxWorkgroupSize{ cooperativeMatrixWorkgroupScopeMaxWorkgroupSize_ }
+      , cooperativeMatrixFlexibleDimensionsMaxDimension{ cooperativeMatrixFlexibleDimensionsMaxDimension_ }
+      , cooperativeMatrixWorkgroupScopeReservedSharedMemory{ cooperativeMatrixWorkgroupScopeReservedSharedMemory_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2PropertiesNV( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceCooperativeMatrix2PropertiesNV( VkPhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceCooperativeMatrix2PropertiesNV( *reinterpret_cast<PhysicalDeviceCooperativeMatrix2PropertiesNV const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceCooperativeMatrix2PropertiesNV & operator=( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
+
+    PhysicalDeviceCooperativeMatrix2PropertiesNV & operator=( VkPhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV const *>( &rhs );
+      return *this;
+    }
+
+    operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>( this );
+    }
+
+    operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
+    auto
+#  else
+    std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, uint32_t const &, uint32_t const &>
+#  endif
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       cooperativeMatrixWorkgroupScopeMaxWorkgroupSize,
+                       cooperativeMatrixFlexibleDimensionsMaxDimension,
+                       cooperativeMatrixWorkgroupScopeReservedSharedMemory );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceCooperativeMatrix2PropertiesNV const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( cooperativeMatrixWorkgroupScopeMaxWorkgroupSize == rhs.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize ) &&
+             ( cooperativeMatrixFlexibleDimensionsMaxDimension == rhs.cooperativeMatrixFlexibleDimensionsMaxDimension ) &&
+             ( cooperativeMatrixWorkgroupScopeReservedSharedMemory == rhs.cooperativeMatrixWorkgroupScopeReservedSharedMemory );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    VULKAN_HPP_NAMESPACE::StructureType sType                                               = StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV;
+    void *                              pNext                                               = {};
+    uint32_t                            cooperativeMatrixWorkgroupScopeMaxWorkgroupSize     = {};
+    uint32_t                            cooperativeMatrixFlexibleDimensionsMaxDimension     = {};
+    uint32_t                            cooperativeMatrixWorkgroupScopeReservedSharedMemory = {};
+  };
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV>
+  {
+    using Type = PhysicalDeviceCooperativeMatrix2PropertiesNV;
+  };
+
   struct PhysicalDeviceCooperativeMatrixFeaturesKHR
   {
     using NativeType = VkPhysicalDeviceCooperativeMatrixFeaturesKHR;

include/vulkan/vulkan_to_string.hpp

@@ -4653,6 +4653,9 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::eImageAlignmentControlCreateInfoMESA: return "ImageAlignmentControlCreateInfoMESA";
       case StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT: return "PhysicalDeviceDepthClampControlFeaturesEXT";
       case StructureType::ePipelineViewportDepthClampControlCreateInfoEXT: return "PipelineViewportDepthClampControlCreateInfoEXT";
+      case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV: return "PhysicalDeviceCooperativeMatrix2FeaturesNV";
+      case StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV: return "CooperativeMatrixFlexibleDimensionsPropertiesNV";
+      case StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV: return "PhysicalDeviceCooperativeMatrix2PropertiesNV";
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }

registry/parse_dependency.py

@@ -110,8 +110,8 @@ def push_first(toks):
 
     exprStack.append(toks[0])
 
-# An identifier (version or extension name)
+# An identifier (version, feature boolean, or extension name)
-dependencyIdent = Word(alphanums + '_')
+dependencyIdent = Word(alphanums + '_' + ':')
 
 # Infix expression for depends expressions
 dependencyExpr = pp.infixNotation(dependencyIdent,

registry/vk.xml

@@ -76,6 +76,7 @@ branch of the member gitlab server.
         <tag name="FB"          author="Facebook, Inc"                 contact="Artem Bolgar @artyom17"/>
         <tag name="RASTERGRID"  author="RasterGrid Kft."               contact="Daniel Rakos @aqnuep"/>
         <tag name="MSFT"        author="Microsoft Corporation"         contact="Jesse Natalie @jenatali"/>
+        <tag name="SHADY"       author="Saarland University"           contact="Hugo Devillers @hugobros3"/>
     </tags>
 
     <types comment="Vulkan type definitions">
@@ -175,7 +176,7 @@ branch of the member gitlab server.
 #define <name>VKSC_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0</type>
 
         <type api="vulkan" category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 299</type>
+#define <name>VK_HEADER_VERSION</name> 300</type>
         <type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 3, VK_HEADER_VERSION)</type>
         <type api="vulkansc" category="define">// Version of this file
@@ -9424,6 +9425,38 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <member><type>float</type>          <name>minDepthClamp</name></member>
             <member><type>float</type>          <name>maxDepthClamp</name></member>
         </type>
+        <type category="struct" name="VkPhysicalDeviceCooperativeMatrix2FeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true"><type>void</type>*               <name>pNext</name></member>
+            <member><type>VkBool32</type>                            <name>cooperativeMatrixWorkgroupScope</name></member>
+            <member><type>VkBool32</type>                            <name>cooperativeMatrixFlexibleDimensions</name></member>
+            <member><type>VkBool32</type>                            <name>cooperativeMatrixReductions</name></member>
+            <member><type>VkBool32</type>                            <name>cooperativeMatrixConversions</name></member>
+            <member><type>VkBool32</type>                            <name>cooperativeMatrixPerElementOperations</name></member>
+            <member><type>VkBool32</type>                            <name>cooperativeMatrixTensorAddressing</name></member>
+            <member><type>VkBool32</type>                            <name>cooperativeMatrixBlockLoads</name></member>
+        </type>
+        <type category="struct" name="VkPhysicalDeviceCooperativeMatrix2PropertiesNV" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
+            <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true"><type>void</type>*                 <name>pNext</name></member>
+            <member limittype="max"><type>uint32_t</type>              <name>cooperativeMatrixWorkgroupScopeMaxWorkgroupSize</name></member>
+            <member limittype="max"><type>uint32_t</type>              <name>cooperativeMatrixFlexibleDimensionsMaxDimension</name></member>
+            <member limittype="max"><type>uint32_t</type>              <name>cooperativeMatrixWorkgroupScopeReservedSharedMemory</name></member>
+        </type>
+        <type category="struct" name="VkCooperativeMatrixFlexibleDimensionsPropertiesNV" returnedonly="true">
+            <member values="VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
+            <member optional="true"><type>void</type>*               <name>pNext</name></member>
+            <member><type>uint32_t</type>                            <name>MGranularity</name></member>
+            <member><type>uint32_t</type>                            <name>NGranularity</name></member>
+            <member><type>uint32_t</type>                            <name>KGranularity</name></member>
+            <member><type>VkComponentTypeKHR</type>                  <name>AType</name></member>
+            <member><type>VkComponentTypeKHR</type>                  <name>BType</name></member>
+            <member><type>VkComponentTypeKHR</type>                  <name>CType</name></member>
+            <member><type>VkComponentTypeKHR</type>                  <name>ResultType</name></member>
+            <member><type>VkBool32</type>                            <name>saturatingAccumulation</name></member>
+            <member><type>VkScopeKHR</type>                          <name>scope</name></member>
+            <member><type>uint32_t</type>                            <name>workgroupInvocations</name></member>
+        </type>
     </types>
 
 
@@ -15844,6 +15877,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <param><type>VkDepthClampModeEXT</type> <name>depthClampMode</name></param>
             <param optional="true">const <type>VkDepthClampRangeEXT</type>* <name>pDepthClampRange</name></param>
         </command>
+        <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
+            <proto><type>VkResult</type> <name>vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV</name></proto>
+            <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
+            <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param>
+            <param optional="true" len="pPropertyCount"><type>VkCooperativeMatrixFlexibleDimensionsPropertiesNV</type>* <name>pProperties</name></param>
+        </command>
     </commands>
 
     <feature api="vulkan,vulkansc" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
@@ -16390,6 +16429,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <enum extends="VkStructureType" extnumber="84"  offset="0"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"/>
             <type name="VkPhysicalDevice16BitStorageFeatures"/>
         </require>
+        <require depends="VkPhysicalDevice16BitStorageFeatures::uniformAndStorageBuffer16BitAccess">
+            <feature name="storageBuffer16BitAccess" struct="VkPhysicalDevice16BitStorageFeatures"/>
+        </require>
         <require comment="Promoted from VK_KHR_dedicated_allocation">
             <enum extends="VkStructureType" extnumber="128" offset="0"          name="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"/>
             <enum extends="VkStructureType" extnumber="128" offset="1"          name="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"/>
@@ -16754,6 +16796,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <enum offset="0" extends="VkStructureType" extnumber="178"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"/>
             <type name="VkPhysicalDevice8BitStorageFeatures"/>
         </require>
+        <require depends="VkPhysicalDevice8BitStorageFeatures::uniformAndStorageBuffer8BitAccess">
+            <feature name="storageBuffer8BitAccess" struct="VkPhysicalDevice8BitStorageFeatures"/>
+            <feature name="storageBuffer8BitAccess" struct="VkPhysicalDeviceVulkan12Features"/>
+        </require>
         <require comment="Promoted from VK_KHR_driver_properties (extension 197)">
             <enum offset="0" extends="VkStructureType" extnumber="197"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"/>
             <enum name="VK_MAX_DRIVER_NAME_SIZE"/>
@@ -16766,6 +16812,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <enum offset="0" extends="VkStructureType" extnumber="181"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"/>
             <type name="VkPhysicalDeviceShaderAtomicInt64Features"/>
         </require>
+        <require depends="VkPhysicalDeviceShaderAtomicInt64Features::shaderSharedInt64Atomics,VkPhysicalDeviceShaderAtomicInt64Features::shaderBufferInt64Atomics">
+            <feature name="shaderInt64" struct="VkPhysicalDeviceFeatures"/>
+        </require>
         <require comment="Promoted from VK_KHR_shader_float16_int8 (extension 83)">
             <enum offset="0" extends="VkStructureType" extnumber="83"           name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"/>
             <type name="VkPhysicalDeviceShaderFloat16Int8Features"/>
@@ -16793,7 +16842,24 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <type name="VkDescriptorBindingFlags"/>
         </require>
         <require depends="VK_EXT_descriptor_indexing">
-                <feature name="descriptorIndexing" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="descriptorIndexing" struct="VkPhysicalDeviceVulkan12Features"/>
+        </require>
+        <require depends="VkPhysicalDeviceVulkan12Features::descriptorIndexing">
+            <feature name="shaderSampledImageArrayDynamicIndexing" struct="VkPhysicalDeviceFeatures"/>
+            <feature name="shaderStorageBufferArrayDynamicIndexing" struct="VkPhysicalDeviceFeatures"/>
+            <feature name="shaderUniformTexelBufferArrayDynamicIndexing" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="shaderStorageTexelBufferArrayDynamicIndexing" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="shaderSampledImageArrayNonUniformIndexing" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="shaderStorageBufferArrayNonUniformIndexing" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="shaderUniformTexelBufferArrayNonUniformIndexing" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="descriptorBindingSampledImageUpdateAfterBind" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="descriptorBindingStorageImageUpdateAfterBind" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="descriptorBindingStorageBufferUpdateAfterBind" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="descriptorBindingUniformTexelBufferUpdateAfterBind" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="descriptorBindingStorageTexelBufferUpdateAfterBind" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="descriptorBindingUpdateUnusedWhilePending" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="descriptorBindingPartiallyBound" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="runtimeDescriptorArray" struct="VkPhysicalDeviceVulkan12Features"/>
         </require>
         <require comment="Promoted from VK_KHR_depth_stencil_resolve (extension 200)">
             <enum offset="0" extends="VkStructureType" extnumber="200"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"/>
@@ -16842,16 +16908,19 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <enum offset="3" extends="VkStructureType" extnumber="109"          name="VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"/>
             <enum bitpos="0" extends="VkFramebufferCreateFlagBits"              name="VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"/>
             <feature name="imagelessFramebuffer" struct="VkPhysicalDeviceImagelessFramebufferFeatures"/>
+            <feature name="imagelessFramebuffer" struct="VkPhysicalDeviceVulkan12Features"/>
         </require>
         <require comment="Promoted from VK_KHR_uniform_buffer_standard_layout (extension 254)">
             <type name="VkPhysicalDeviceUniformBufferStandardLayoutFeatures"/>
             <enum offset="0" extends="VkStructureType" extnumber="254"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"/>
             <feature name="uniformBufferStandardLayout" struct="VkPhysicalDeviceUniformBufferStandardLayoutFeatures"/>
+            <feature name="uniformBufferStandardLayout" struct="VkPhysicalDeviceVulkan12Features"/>
         </require>
         <require comment="Promoted from VK_KHR_shader_subgroup_extended_types (extension 176)">
             <enum offset="0" extends="VkStructureType" extnumber="176"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"/>
             <type name="VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"/>
             <feature name="shaderSubgroupExtendedTypes" struct="VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"/>
+            <feature name="shaderSubgroupExtendedTypes" struct="VkPhysicalDeviceVulkan12Features"/>
         </require>
         <require comment="Promoted from VK_KHR_spirv_1_4 (extension 237)">
         </require>
@@ -16867,12 +16936,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <type name="VkAttachmentReferenceStencilLayout"/>
             <type name="VkAttachmentDescriptionStencilLayout"/>
             <feature name="separateDepthStencilLayouts" struct="VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"/>
+            <feature name="separateDepthStencilLayouts" struct="VkPhysicalDeviceVulkan12Features"/>
         </require>
         <require comment="Promoted from VK_EXT_host_query_reset (extension 262)">
             <enum offset="0" extends="VkStructureType" extnumber="262"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"/>
             <type name="VkPhysicalDeviceHostQueryResetFeatures"/>
             <command name="vkResetQueryPool"/>
             <feature name="hostQueryReset" struct="VkPhysicalDeviceHostQueryResetFeatures"/>
+            <feature name="hostQueryReset" struct="VkPhysicalDeviceVulkan12Features"/>
         </require>
         <require comment="Promoted from VK_KHR_timeline_semaphore (extension 208)">
             <enum offset="0" extends="VkStructureType" extnumber="208"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"/>
@@ -16894,6 +16965,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <command name="vkWaitSemaphores"/>
             <command name="vkSignalSemaphore"/>
             <feature name="timelineSemaphore" struct="VkPhysicalDeviceTimelineSemaphoreFeatures"/>
+            <feature name="timelineSemaphore" struct="VkPhysicalDeviceVulkan12Features"/>
         </require>
         <require comment="Promoted from VK_KHR_buffer_device_address (extension 258)">
             <enum offset="0" extends="VkStructureType" extnumber="258"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"/>
@@ -16940,6 +17012,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <enum offset="0" extends="VkStructureType"  extnumber="216"         name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES"/>
             <type name="VkPhysicalDeviceShaderTerminateInvocationFeatures"/>
             <feature name="shaderTerminateInvocation" struct="VkPhysicalDeviceShaderTerminateInvocationFeatures"/>
+            <feature name="shaderTerminateInvocation" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_EXT_tooling_info (extension 246)">
             <enum offset="0" extends="VkStructureType"  extnumber="246"         name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES"/>
@@ -16952,6 +17025,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <enum offset="0" extends="VkStructureType"  extnumber="277"         name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES"/>
             <type name="VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures"/>
             <feature name="shaderDemoteToHelperInvocation" struct="VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures"/>
+            <feature name="shaderDemoteToHelperInvocation" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_KHR_shader_non_semantic_info (extension 294)">
         </require>
@@ -16970,6 +17044,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <command name="vkSetPrivateData"/>
             <command name="vkGetPrivateData"/>
             <feature name="privateData" struct="VkPhysicalDevicePrivateDataFeatures"/>
+            <feature name="privateData" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_EXT_pipeline_creation_cache_control (extension 298)">
             <enum offset="0" extends="VkStructureType"  extnumber="298"         name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES"/>
@@ -16979,6 +17054,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <enum offset="0" extends="VkResult"         extnumber="298"         name="VK_PIPELINE_COMPILE_REQUIRED"/>
             <enum bitpos="0" extends="VkPipelineCacheCreateFlagBits"            name="VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT"/>
             <feature name="pipelineCreationCacheControl" struct="VkPhysicalDevicePipelineCreationCacheControlFeatures"/>
+            <feature name="pipelineCreationCacheControl" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_KHR_synchronization2 (extension 315)">
             <enum offset="0" extends="VkStructureType"  extnumber="315"         name="VK_STRUCTURE_TYPE_MEMORY_BARRIER_2"/>
@@ -17015,16 +17091,19 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <command name="vkCmdWriteTimestamp2"/>
             <command name="vkQueueSubmit2"/>
             <feature name="synchronization2" struct="VkPhysicalDeviceSynchronization2Features"/>
+            <feature name="synchronization2" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_KHR_zero_initialize_workgroup_memory (extension 326)">
             <enum offset="0" extends="VkStructureType"  extnumber="326"         name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES"/>
             <type name="VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"/>
                 <feature name="shaderZeroInitializeWorkgroupMemory" struct="VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"/>
+                <feature name="shaderZeroInitializeWorkgroupMemory" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_EXT_image_robustness (extension 336)">
             <enum offset="0" extends="VkStructureType"  extnumber="336"         name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES"/>
             <type name="VkPhysicalDeviceImageRobustnessFeatures"/>
             <feature name="robustImageAccess" struct="VkPhysicalDeviceImageRobustnessFeatures"/>
+            <feature name="robustImageAccess" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_KHR_copy_commands2 (extension 338)">
             <enum offset="0" extends="VkStructureType"  extnumber="338"         name="VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2"/>
@@ -17067,6 +17146,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <enum bitpos="1" extends="VkPipelineShaderStageCreateFlagBits"      name="VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT"/>
             <feature name="subgroupSizeControl" struct="VkPhysicalDeviceSubgroupSizeControlFeatures"/>
             <feature name="computeFullSubgroups" struct="VkPhysicalDeviceSubgroupSizeControlFeatures"/>
+            <feature name="subgroupSizeControl" struct="VkPhysicalDeviceVulkan13Features"/>
+            <feature name="computeFullSubgroups" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_EXT_inline_uniform_block (STDPROMOTE/PROPLIMCHANGE) (extension 139)">
             <enum offset="0" extends="VkDescriptorType" extnumber="139"         name="VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK"/>
@@ -17124,6 +17205,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <type name="VkRenderingFlags"/>
             <type name="VkRenderingFlagBits"/>
             <feature name="dynamicRendering" struct="VkPhysicalDeviceDynamicRenderingFeatures"/>
+            <feature name="dynamicRendering" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_EXT_extended_dynamic_state (Feature struct is not promoted) (extension 268)">
             <enum offset="0" extends="VkDynamicState"  extnumber="268"          name="VK_DYNAMIC_STATE_CULL_MODE"/>
@@ -17157,6 +17239,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <type name="VkPhysicalDeviceShaderIntegerDotProductFeatures"/>
             <type name="VkPhysicalDeviceShaderIntegerDotProductProperties"/>
             <feature name="shaderIntegerDotProduct" struct="VkPhysicalDeviceShaderIntegerDotProductFeatures"/>
+            <feature name="shaderIntegerDotProduct" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require comment="Promoted from VK_EXT_texel_buffer_alignment (extension 282)">
             <enum offset="1" extends="VkStructureType" extnumber="282"          name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES"/>
@@ -17190,15 +17273,21 @@ typedef void* <name>MTLSharedEvent_id</name>;
             <command name="vkGetDeviceImageMemoryRequirements"/>
             <command name="vkGetDeviceImageSparseMemoryRequirements"/>
             <feature name="maintenance4" struct="VkPhysicalDeviceMaintenance4Features"/>
+            <feature name="maintenance4" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
         <require>
             <feature name="vulkanMemoryModel" struct="VkPhysicalDeviceVulkanMemoryModelFeatures"/>
             <feature name="vulkanMemoryModelDeviceScope" struct="VkPhysicalDeviceVulkanMemoryModelFeatures"/>
             <feature name="inlineUniformBlock" struct="VkPhysicalDeviceInlineUniformBlockFeatures"/>
             <feature name="bufferDeviceAddress" struct="VkPhysicalDeviceBufferDeviceAddressFeatures"/>
+            <feature name="vulkanMemoryModel" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="vulkanMemoryModelDeviceScope" struct="VkPhysicalDeviceVulkan12Features"/>
+            <feature name="inlineUniformBlock" struct="VkPhysicalDeviceVulkan13Features"/>
+            <feature name="bufferDeviceAddress" struct="VkPhysicalDeviceVulkan12Features"/>
         </require>
-        <require depends="VK_EXT_descriptor_indexing">
+        <require depends="VK_EXT_descriptor_indexing,VkPhysicalDeviceVulkan12Features::descriptorIndexing">
             <feature name="descriptorBindingInlineUniformBlockUpdateAfterBind" struct="VkPhysicalDeviceInlineUniformBlockFeatures"/>
+            <feature name="descriptorBindingInlineUniformBlockUpdateAfterBind" struct="VkPhysicalDeviceVulkan13Features"/>
         </require>
     </feature>
 
@@ -17258,6 +17347,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
         </require>
         <require depends="VK_VERSION_1_2">
             <feature name="vulkanMemoryModel" struct="VkPhysicalDeviceVulkanMemoryModelFeatures"/>
+            <feature name="vulkanMemoryModel" struct="VkPhysicalDeviceVulkan12Features"/>
         </require>
 
         <remove comment="SC 1.0 removes some features from Vulkan 1.0/1.1/1.2">
@@ -17340,7 +17430,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
 
         <remove reasonlink="SCID-8">
             <feature name="multiview" struct="VkPhysicalDeviceMultiviewFeatures"/>
+            <feature name="multiview" struct="VkPhysicalDeviceVulkan11Features"/>
             <feature name="timelineSemaphore" struct="VkPhysicalDeviceTimelineSemaphoreFeatures"/>
+            <feature name="timelineSemaphore" struct="VkPhysicalDeviceVulkan12Features"/>
         </remove>
     </feature>
 
@@ -18352,7 +18444,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="textureCompressionASTC_HDR" struct="VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT"/>
             </require>
         </extension>
-        <extension name="VK_EXT_astc_decode_mode" number="68" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan,vulkansc">
+        <extension name="VK_EXT_astc_decode_mode" number="68" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan,vulkansc" ratified="vulkan">
             <require>
                 <enum value="1"                                                 name="VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_astc_decode_mode&quot;"               name="VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME"/>
@@ -18595,6 +18687,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum extends="VkStructureType"                             name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"/>
                 <type name="VkPhysicalDeviceShaderFloat16Int8FeaturesKHR"/>
                 <type name="VkPhysicalDeviceFloat16Int8FeaturesKHR"/>
+                <feature name="shaderFloat16,shaderInt8" struct="VkPhysicalDeviceShaderFloat16Int8FeaturesKHR"/>
             </require>
         </extension>
         <extension name="VK_KHR_16bit_storage" number="84" type="device" depends="(VK_KHR_get_physical_device_properties2+VK_KHR_storage_buffer_storage_class),VK_VERSION_1_1" author="KHR" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan" promotedto="VK_VERSION_1_1" ratified="vulkan">
@@ -18657,7 +18750,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <command name="vkCmdSetViewportWScalingNV"/>
             </require>
         </extension>
-        <extension name="VK_EXT_direct_mode_display" number="89" type="instance" depends="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan,vulkansc">
+        <extension name="VK_EXT_direct_mode_display" number="89" type="instance" depends="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan,vulkansc" ratified="vulkan">
             <require>
                 <enum value="1"                                             name="VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_direct_mode_display&quot;"        name="VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME"/>
@@ -18829,7 +18922,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum bitpos="0"  extends="VkPrivateDataSlotCreateFlagBits" name="VK_PRIVATE_DATA_SLOT_CREATE_RESERVED_0_BIT_NV"/>
             </require>
         </extension>
-        <extension name="VK_EXT_swapchain_colorspace" number="105" type="instance" depends="VK_KHR_surface" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" supported="vulkan,vulkansc">
+        <extension name="VK_EXT_swapchain_colorspace" number="105" type="instance" depends="VK_KHR_surface" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" supported="vulkan,vulkansc" ratified="vulkan">
             <require>
                 <enum value="5"                                             name="VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_swapchain_colorspace&quot;"       name="VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME"/>
@@ -19160,7 +19253,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <type name="VkMemoryDedicatedAllocateInfoKHR"/>
             </require>
         </extension>
-        <extension name="VK_EXT_debug_utils" number="129" type="instance" author="EXT" contact="Mark Young @marky-lunarg" specialuse="debugging" supported="vulkan,vulkansc">
+        <extension name="VK_EXT_debug_utils" number="129" type="instance" author="EXT" contact="Mark Young @marky-lunarg" specialuse="debugging" supported="vulkan,vulkansc" ratified="vulkan">
             <require>
                 <enum value="2"                                             name="VK_EXT_DEBUG_UTILS_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_debug_utils&quot;"                name="VK_EXT_DEBUG_UTILS_EXTENSION_NAME"/>
@@ -19339,7 +19432,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="inlineUniformBlock" struct="VkPhysicalDeviceInlineUniformBlockFeaturesEXT"/>
             </require>
             <require depends="VK_EXT_descriptor_indexing">
-                <feature name="descriptorBindingInlineUniformBlockUpdateAfterBind" struct="VkPhysicalDeviceInlineUniformBlockFeaturesEXT"/>
+                <feature name="descriptorBindingInlineUniformBlockUpdateAfterBind" struct="VkPhysicalDeviceInlineUniformBlockFeatures"/>
+            </require>
+            <require depends="VK_VERSION_1_2+VkPhysicalDeviceVulkan12Features::descriptorIndexing">
+                <feature name="descriptorBindingInlineUniformBlockUpdateAfterBind" struct="VkPhysicalDeviceInlineUniformBlockFeatures"/>
             </require>
         </extension>
         <extension name="VK_AMD_extension_140" number="140" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled">
@@ -19931,6 +20027,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <command name="vkCmdBindShadingRateImageNV"/>
                 <command name="vkCmdSetViewportShadingRatePaletteNV"/>
                 <command name="vkCmdSetCoarseSampleOrderNV"/>
+                <feature name="shadingRateImage" struct="VkPhysicalDeviceShadingRateImageFeaturesNV"/>
             </require>
         </extension>
         <extension name="VK_NV_ray_tracing" number="166" type="device" depends="(VK_KHR_get_physical_device_properties2+VK_KHR_get_memory_requirements2),VK_VERSION_1_1" author="NV" contact="Eric Werness @ewerness-nv" supported="vulkan" deprecatedby="VK_KHR_ray_tracing_pipeline">
@@ -20041,6 +20138,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum offset="1" extends="VkStructureType"  name="VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"/>
                 <type name="VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV"/>
                 <type name="VkPipelineRepresentativeFragmentTestStateCreateInfoNV"/>
+                <feature name="representativeFragmentTest" struct="VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_168" number="168" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
@@ -20998,14 +21096,16 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <type name="VkCoverageReductionModeNV"/>
                 <type name="VkFramebufferMixedSamplesCombinationNV"/>
                 <command name="vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"/>
+                <feature name="coverageReductionMode" struct="VkPhysicalDeviceCoverageReductionModeFeaturesNV"/>
             </require>
         </extension>
-        <extension name="VK_EXT_fragment_shader_interlock" number="252" author="EXT" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc">
+        <extension name="VK_EXT_fragment_shader_interlock" number="252" author="EXT" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc" ratified="vulkan">
             <require>
                 <enum value="1"                                                 name="VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_fragment_shader_interlock&quot;"      name="VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                      name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT"/>
                 <type name="VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT"/>
+                <feature name="fragmentShaderSampleInterlock,fragmentShaderPixelInterlock,fragmentShaderShadingRateInterlock" struct="VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT"/>
             </require>
         </extension>
         <extension name="VK_EXT_ycbcr_image_arrays" number="253" type="device" depends="VK_KHR_sampler_ycbcr_conversion,VK_VERSION_1_1" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc" ratified="vulkan,vulkansc">
@@ -21062,7 +21162,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <command name="vkGetDeviceGroupSurfacePresentModes2EXT"/>
             </require>
         </extension>
-        <extension name="VK_EXT_headless_surface" number="257" type="instance" depends="VK_KHR_surface" author="EXT" contact="Lisa Wu @chengtianww" supported="vulkan,vulkansc">
+        <extension name="VK_EXT_headless_surface" number="257" type="instance" depends="VK_KHR_surface" author="EXT" contact="Lisa Wu @chengtianww" supported="vulkan,vulkansc" ratified="vulkan">
             <require>
                 <enum value="1"                                                 name="VK_EXT_HEADLESS_SURFACE_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_headless_surface&quot;"               name="VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME"/>
@@ -21120,6 +21220,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <type name="VkPipelineRasterizationLineStateCreateInfoEXT"/>
                 <type name="VkLineRasterizationModeEXT"/>
                 <command name="vkCmdSetLineStippleEXT"/>
+                <feature name="rectangularLines,bresenhamLines,smoothLines,stippledRectangularLines,stippledBresenhamLines,stippledSmoothLines" struct="VkPhysicalDeviceLineRasterizationFeaturesEXT"/>
             </require>
         </extension>
         <extension name="VK_EXT_shader_atomic_float" number="261" type="device" author="NV" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan,vulkansc" ratified="vulkan,vulkansc">
@@ -21129,6 +21230,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT"/>
                 <type name="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"/>
             </require>
+            <require depends="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::sparseImageFloat32Atomics">
+                <feature name="shaderImageFloat32Atomics" struct="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"/>
+            </require>
+            <require depends="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::sparseImageFloat32AtomicAdd">
+                <feature name="shaderImageFloat32AtomicAdd" struct="VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"/>
+            </require>
         </extension>
         <extension name="VK_EXT_host_query_reset" number="262" author="EXT" contact="Bas Nieuwenhuizen @BNieuwenhuizen" supported="vulkan" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" promotedto="VK_VERSION_1_2">
             <require>
@@ -21324,6 +21431,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT"/>
                 <type name="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT"/>
             </require>
+            <require depends="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::sparseImageFloat32AtomicMinMax">
+                <feature name="shaderImageFloat32AtomicMinMax" struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT"/>
+            </require>
         </extension>
         <extension name="VK_EXT_surface_maintenance1" number="275" type="instance" depends="VK_KHR_surface+VK_KHR_get_surface_capabilities2" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan">
             <require>
@@ -22226,6 +22336,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum offset="0" extends="VkIndirectCommandsTokenTypeEXT" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT"/>
                 <enum offset="1" extends="VkIndirectCommandsTokenTypeEXT" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT"/>
             </require>
+            <require depends="VK_KHR_fragment_shading_rate+VkPhysicalDeviceMeshShaderFeaturesEXT::primitiveFragmentShadingRateMeshShader">
+                <feature name="primitiveFragmentShadingRate" struct="VkPhysicalDeviceFragmentShadingRateFeaturesKHR"/>
+            </require>
         </extension>
         <extension name="VK_NV_extension_330" number="330" author="NV" contact="Liam Middlebrook @liam-middlebrook" supported="disabled">
             <require>
@@ -22495,7 +22608,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="vertexInputDynamicState" struct="VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT"/>
             </require>
         </extension>
-        <extension name="VK_EXT_physical_device_drm" number="354" author="EXT" type="device" contact="Simon Ser @emersion" supported="vulkan" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1">
+        <extension name="VK_EXT_physical_device_drm" number="354" author="EXT" type="device" contact="Simon Ser @emersion" supported="vulkan" ratified="vulkan" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1">
             <require>
                 <enum value="1"                                             name="VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_physical_device_drm&quot;"        name="VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME"/>
@@ -22759,6 +22872,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <command name="vkGetPhysicalDeviceSciSyncAttributesNV"/>
                 <command name="vkGetSemaphoreSciSyncObjNV"/>
                 <command name="vkImportSemaphoreSciSyncObjNV"/>
+                <feature name="sciSyncFence,sciSyncSemaphore" struct="VkPhysicalDeviceExternalSciSyncFeaturesNV"/>
+                <feature name="sciSyncImport,sciSyncExport" struct="VkPhysicalDeviceExternalSciSyncFeaturesNV"/>
             </require>
         </extension>
         <extension name="VK_NV_external_memory_sci_buf" number="375" depends="VK_VERSION_1_1" platform="sci" type="device" author="NV" contact="Kai Zhang @kazhang" supported="vulkansc">
@@ -22781,6 +22896,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <command name="vkGetMemorySciBufNV"/>
                 <command name="vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV"/>
                 <command name="vkGetPhysicalDeviceSciBufAttributesNV"/>
+                <feature name="sciBufImport,sciBufExport" struct="VkPhysicalDeviceExternalSciBufFeaturesNV"/>
             </require>
         </extension>
         <extension name="VK_EXT_frame_boundary" number="376" type="device" author="EXT" contact="James Fitzpatrick @jamesfitzpatrick" supported="vulkan" ratified="vulkan">
@@ -22865,7 +22981,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="colorWriteEnable" struct="VkPhysicalDeviceColorWriteEnableFeaturesEXT"/>
             </require>
         </extension>
-        <extension name="VK_EXT_primitives_generated_query" number="383" type="device" depends="VK_EXT_transform_feedback" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" specialuse="glemulation">
+        <extension name="VK_EXT_primitives_generated_query" number="383" type="device" depends="VK_EXT_transform_feedback" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" specialuse="glemulation" ratified="vulkan">
             <require>
                 <enum value="1"                                                 name="VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_primitives_generated_query&quot;"     name="VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME"/>
@@ -22948,7 +23064,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_EXT_extension_391&quot;"              name="VK_EXT_EXTENSION_391_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_EXT_image_view_min_lod" number="392" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Joshua Ashton @Joshua-Ashton" supported="vulkan">
+        <extension name="VK_EXT_image_view_min_lod" number="392" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Joshua Ashton @Joshua-Ashton" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1"                                             name="VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_image_view_min_lod&quot;"         name="VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME"/>
@@ -22959,7 +23075,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="minLod" struct="VkPhysicalDeviceImageViewMinLodFeaturesEXT"/>
             </require>
         </extension>
-        <extension name="VK_EXT_multi_draw" number="393" author="EXT" contact="Mike Blumenkrantz @zmike" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan">
+        <extension name="VK_EXT_multi_draw" number="393" author="EXT" contact="Mike Blumenkrantz @zmike" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1"                                         name="VK_EXT_MULTI_DRAW_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_multi_draw&quot;"             name="VK_EXT_MULTI_DRAW_EXTENSION_NAME"/>
@@ -23177,7 +23293,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_GGP_extension_411&quot;"          name="VK_GGP_EXTENSION_411_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_EXT_border_color_swizzle" number="412" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan" depends="VK_EXT_custom_border_color" specialuse="glemulation,d3demulation">
+        <extension name="VK_EXT_border_color_swizzle" number="412" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan" depends="VK_EXT_custom_border_color" specialuse="glemulation,d3demulation" ratified="vulkan">
             <require>
                 <enum value="1"                                         name="VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_border_color_swizzle&quot;"   name="VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME"/>
@@ -23299,7 +23415,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <feature name="depthClampZeroOne" struct="VkPhysicalDeviceDepthClampZeroOneFeaturesEXT"/>
             </require>
         </extension>
-        <extension name="VK_EXT_non_seamless_cube_map" number="423" author="EXT" type="device" contact="Georg Lehmann @DadSchoorse" specialuse="d3demulation,glemulation" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan">
+        <extension name="VK_EXT_non_seamless_cube_map" number="423" author="EXT" type="device" contact="Georg Lehmann @DadSchoorse" specialuse="d3demulation,glemulation" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan" ratified="vulkan">
             <require>
                 <enum value="1"                                             name="VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_non_seamless_cube_map&quot;"      name="VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME"/>
@@ -23709,6 +23825,24 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum offset="32" extends="VkDynamicState"                   name="VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV"/>
                 <command name="vkCmdSetCoverageReductionModeNV"/>
             </require>
+            <require depends="VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3TessellationDomainOrigin">
+                <feature name="tessellationShader" struct="VkPhysicalDeviceFeatures"/>
+            </require>
+            <require depends="VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3DepthClampEnable">
+                <feature name="depthClamp" struct="VkPhysicalDeviceFeatures"/>
+            </require>
+            <require depends="VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3PolygonMode">
+                <feature name="fillModeNonSolid" struct="VkPhysicalDeviceFeatures"/>
+            </require>
+            <require depends="VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3AlphaToOneEnable">
+                <feature name="alphaToOne" struct="VkPhysicalDeviceFeatures"/>
+            </require>
+            <require depends="VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3LogicOpEnable">
+                <feature name="logicOp" struct="VkPhysicalDeviceFeatures"/>
+            </require>
+            <require depends="VK_EXT_transform_feedback+VkPhysicalDeviceMeshShaderFeaturesEXT::extendedDynamicState3RasterizationStream">
+                <feature name="geometryStreams" struct="VkPhysicalDeviceTransformFeedbackFeaturesEXT"/>
+            </require>
         </extension>
         <extension name="VK_EXT_extension_457" number="457" author="RASTERGRID" contact="Daniel Rakos @aqnuep" supported="disabled">
             <require>
@@ -24343,6 +24477,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <type name="VkSemaphoreSciSyncCreateInfoNV"/>
                 <command name="vkCreateSemaphoreSciSyncPoolNV"/>
                 <command name="vkDestroySemaphoreSciSyncPoolNV"/>
+                <feature name="sciSyncFence,sciSyncSemaphore2" struct="VkPhysicalDeviceExternalSciSync2FeaturesNV"/>
+                <feature name="sciSyncImport,sciSyncExport" struct="VkPhysicalDeviceExternalSciSync2FeaturesNV"/>
             </require>
             <require comment="functionality re-used unmodified from VK_NV_external_sci_sync">
                 <enum extnumber="374" offset="0" extends="VkStructureType"   name="VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV"/>
@@ -24818,6 +24954,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <type name="VkPipelineRasterizationLineStateCreateInfoKHR"/>
                 <type name="VkLineRasterizationModeKHR"/>
                 <command name="vkCmdSetLineStippleKHR"/>
+                <feature name="rectangularLines,bresenhamLines,smoothLines,stippledRectangularLines,stippledBresenhamLines,stippledSmoothLines" struct="VkPhysicalDeviceLineRasterizationFeaturesKHR"/>
             </require>
         </extension>
         <extension name="VK_QCOM_extension_536" number="536" type="device" author="QCOM" contact="Matthew Netsch @mnetsch" supported="disabled">
@@ -25354,10 +25491,18 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_NV_extension_593&quot;"               name="VK_NV_EXTENSION_593_EXTENSION_NAME"/>
             </require>
         </extension>
-        <extension name="VK_NV_extension_594" number="594" author="NV" contact="Jeff Bolz @jeffbolznv" supported="disabled">
+        <extension name="VK_NV_cooperative_matrix2" number="594" type="device" author="NV" depends="VK_KHR_cooperative_matrix" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_NV_EXTENSION_594_SPEC_VERSION"/>
+                <enum value="1"                                             name="VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION"/>
-                <enum value="&quot;VK_NV_extension_594&quot;"               name="VK_NV_EXTENSION_594_EXTENSION_NAME"/>
+                <enum value="&quot;VK_NV_cooperative_matrix2&quot;"         name="VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME"/>
+                <enum offset="0" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV"/>
+                <enum offset="1" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV"/>
+                <enum offset="2" extends="VkStructureType"                   name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV"/>
+                <type name="VkCooperativeMatrixFlexibleDimensionsPropertiesNV"/>
+                <type name="VkPhysicalDeviceCooperativeMatrix2FeaturesNV"/>
+                <type name="VkPhysicalDeviceCooperativeMatrix2PropertiesNV"/>
+                <command name="vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"/>
+                <feature name="cooperativeMatrixWorkgroupScope,cooperativeMatrixFlexibleDimensions,cooperativeMatrixReductions,cooperativeMatrixConversions,cooperativeMatrixPerElementOperations,cooperativeMatrixTensorAddressing,cooperativeMatrixBlockLoads" struct="VkPhysicalDeviceCooperativeMatrix2FeaturesNV"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_595" number="595" author="NV" contact="Jeff Bolz @jeffbolznv" supported="disabled">
@@ -25449,6 +25594,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
                 <enum value="&quot;VK_KHR_extension_608&quot;"              name="VK_KHR_EXTENSION_608_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_NV_extension_609" number="609" author="NV" contact="Piers Daniell @pdaniell-nv" supported="disabled">
+            <require>
+                <enum value="0"                                             name="VK_NV_EXTENSION_609_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_extension_609&quot;"               name="VK_NV_EXTENSION_609_EXTENSION_NAME"/>
+            </require>
+        </extension>
     </extensions>
     <formats>
         <format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">
@@ -27107,6 +27258,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <spirvextension name="SPV_KHR_relaxed_extended_instruction">
             <enable extension="VK_KHR_shader_relaxed_extended_instruction"/>
         </spirvextension>
+        <spirvextension name="SPV_NV_cooperative_matrix2">
+            <enable extension="VK_NV_cooperative_matrix2"/>
+        </spirvextension>
+        <spirvextension name="SPV_NV_tensor_addressing">
+            <enable extension="VK_NV_cooperative_matrix2"/>
+        </spirvextension>
     </spirvextensions>
     <spirvcapabilities comment="SPIR-V Capabilities allowed in Vulkan and what is required to use it">
         <spirvcapability name="Matrix">
@@ -27622,6 +27779,24 @@ typedef void* <name>MTLSharedEvent_id</name>;
         <spirvcapability name="ReplicatedCompositesEXT">
             <enable struct="VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT" feature="shaderReplicatedComposites" requires="VK_EXT_shader_replicated_composites"/>
         </spirvcapability>
+        <spirvcapability name="TensorAddressingNV">
+            <enable struct="VkPhysicalDeviceCooperativeMatrix2FeaturesNV" feature="cooperativeMatrixTensorAddressing" requires="VK_NV_cooperative_matrix2"/>
+        </spirvcapability>
+        <spirvcapability name="CooperativeMatrixReductionsNV">
+            <enable struct="VkPhysicalDeviceCooperativeMatrix2FeaturesNV" feature="cooperativeMatrixReductions" requires="VK_NV_cooperative_matrix2"/>
+        </spirvcapability>
+        <spirvcapability name="CooperativeMatrixConversionsNV">
+            <enable struct="VkPhysicalDeviceCooperativeMatrix2FeaturesNV" feature="cooperativeMatrixConversions" requires="VK_NV_cooperative_matrix2"/>
+        </spirvcapability>
+        <spirvcapability name="CooperativeMatrixPerElementOperationsNV">
+            <enable struct="VkPhysicalDeviceCooperativeMatrix2FeaturesNV" feature="cooperativeMatrixPerElementOperations" requires="VK_NV_cooperative_matrix2"/>
+        </spirvcapability>
+        <spirvcapability name="CooperativeMatrixTensorAddressingNV">
+            <enable struct="VkPhysicalDeviceCooperativeMatrix2FeaturesNV" feature="cooperativeMatrixTensorAddressing" requires="VK_NV_cooperative_matrix2"/>
+        </spirvcapability>
+        <spirvcapability name="CooperativeMatrixBlockLoadsNV">
+            <enable struct="VkPhysicalDeviceCooperativeMatrix2FeaturesNV" feature="cooperativeMatrixBlockLoads" requires="VK_NV_cooperative_matrix2"/>
+        </spirvcapability>
     </spirvcapabilities>
     <sync comment="Machine readable representation of the synchronization objects and their mappings">
         <syncstage name="VK_PIPELINE_STAGE_2_NONE" alias="VK_PIPELINE_STAGE_NONE">