Merge branch 'indev' of github.com:seekrs/MacroLibX into indev

third_party/vulkan/vulkan.cppm

@@ -26,7 +26,7 @@ export module vulkan;
 
 export import std;
 
-VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 358, "Wrong VK_HEADER_VERSION!" );
+VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 359, "Wrong VK_HEADER_VERSION!" );
 
 #if defined( __clang__ )
 #  pragma clang diagnostic push
@@ -1335,6 +1335,9 @@ export
   //=== VK_NV_compute_occupancy_priority ===
   using ::PFN_vkCmdSetComputeOccupancyPriorityNV;
 
+  //=== VK_EXT_cooperative_matrix_maintenance1 ===
+  using ::PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT;
+
 #if defined( VK_USE_PLATFORM_UBM_SEC )
   //=== VK_SEC_ubm_surface ===
   using ::PFN_vkCreateUbmSurfaceSEC;

third_party/vulkan/vulkan.hpp

@@ -36,7 +36,7 @@
 #  endif
 #endif
 
-VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 358, "Wrong VK_HEADER_VERSION!" );
+VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 359, "Wrong VK_HEADER_VERSION!" );
 
 VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
 {
@@ -1719,6 +1719,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCalibrateableTimeDomainsKHR )
     DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCalibrateableTimeDomainsEXT )
     DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV )
+    DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixProperties2EXT )
     DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR )
     DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixPropertiesNV )
     DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeVectorPropertiesNV )
@@ -8206,6 +8207,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
         return ::vkCmdSetComputeOccupancyPriorityNV( commandBuffer, pParameters );
       }
 
+      //=== VK_EXT_cooperative_matrix_maintenance1 ===
+
+      VULKAN_HPP_INLINE VkResult vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( VkPhysicalDevice                                  physicalDevice,
+                                                                                     VkPhysicalDeviceCooperativeMatrixInfo2EXT const * pCooperativeMatrixInfo,
+                                                                                     uint32_t *                                        pPropertyCount,
+                                                                                     VkCooperativeMatrixProperties2EXT * pProperties ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( physicalDevice, pCooperativeMatrixInfo, pPropertyCount, pProperties );
+      }
+
 #    if defined( VK_USE_PLATFORM_UBM_SEC )
       //=== VK_SEC_ubm_surface ===
 
@@ -8511,11 +8522,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
   //=== BASE TYPEs ===
   //==================
 
-  using Bool32          = uint32_t;
-  using DeviceAddress   = uint64_t;
-  using DeviceSize      = uint64_t;
-  using RemoteAddressNV = void *;
   using SampleMask      = uint32_t;
+  using Bool32          = uint32_t;
+  using DeviceSize      = uint64_t;
+  using DeviceAddress   = uint64_t;
+  using RemoteAddressNV = void *;
 
   template <typename Type, Type value = Type{}>
   struct CppType
@@ -11356,6 +11367,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance11SpecVersion   = VK_KHR_MAINTENANCE_11_SPEC_VERSION;
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance11ExtensionName = VK_KHR_MAINTENANCE_11_EXTENSION_NAME;
 
+  //=== VK_EXT_cooperative_matrix_maintenance1 ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto EXTCooperativeMatrixMaintenance1SpecVersion   = VK_EXT_COOPERATIVE_MATRIX_MAINTENANCE_1_SPEC_VERSION;
+  VULKAN_HPP_CONSTEXPR_INLINE auto EXTCooperativeMatrixMaintenance1ExtensionName = VK_EXT_COOPERATIVE_MATRIX_MAINTENANCE_1_EXTENSION_NAME;
+
   //=== VK_EXT_shader_subgroup_partitioned ===
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupPartitionedSpecVersion   = VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION;
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupPartitionedExtensionName = VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME;
@@ -22656,6 +22671,25 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_EXT_cooperative_matrix_maintenance1 ===
+  template <>
+  struct StructExtends<PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_EXT_shader_subgroup_partitioned ===
   template <>
   struct StructExtends<PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT, PhysicalDeviceFeatures2>
@@ -24527,6 +24561,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       //=== VK_NV_compute_occupancy_priority ===
       PFN_vkCmdSetComputeOccupancyPriorityNV vkCmdSetComputeOccupancyPriorityNV = 0;
 
+      //=== VK_EXT_cooperative_matrix_maintenance1 ===
+      PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT vkGetPhysicalDeviceCooperativeMatrixProperties2EXT = 0;
+
 #if defined( VK_USE_PLATFORM_UBM_SEC )
       //=== VK_SEC_ubm_surface ===
       PFN_vkCreateUbmSurfaceSEC                        vkCreateUbmSurfaceSEC                        = 0;
@@ -26290,6 +26327,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
         //=== VK_NV_compute_occupancy_priority ===
         vkCmdSetComputeOccupancyPriorityNV = PFN_vkCmdSetComputeOccupancyPriorityNV( vkGetInstanceProcAddr( instance, "vkCmdSetComputeOccupancyPriorityNV" ) );
 
+        //=== VK_EXT_cooperative_matrix_maintenance1 ===
+        vkGetPhysicalDeviceCooperativeMatrixProperties2EXT =
+          PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixProperties2EXT" ) );
+
 #if defined( VK_USE_PLATFORM_UBM_SEC )
         //=== VK_SEC_ubm_surface ===
         vkCreateUbmSurfaceSEC = PFN_vkCreateUbmSurfaceSEC( vkGetInstanceProcAddr( instance, "vkCreateUbmSurfaceSEC" ) );

third_party/vulkan/vulkan_core.h

@@ -66,7 +66,7 @@ extern "C" {
 //#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 358
+#define VK_HEADER_VERSION 359
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@@ -1470,6 +1470,9 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV = 1000645001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR = 1000657000,
     VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR = 1000657001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_MAINTENANCE_1_FEATURES_EXT = 1000659000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_INFO_2_EXT = 1000659001,
+    VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_2_EXT = 1000659002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT = 1000662000,
     VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC = 1000664000,
     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR = 1000668000,
@@ -6373,6 +6376,7 @@ typedef enum VkDriverId {
     VK_DRIVER_ID_MESA_KOSMICKRISP = 28,
     VK_DRIVER_ID_MESA_GFXSTREAM = 29,
     VK_DRIVER_ID_APE_SOFT = 30,
+    VK_DRIVER_ID_RESERVED_31 = 31,
     VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
     VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
     VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
@@ -26374,6 +26378,60 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetComputeOccupancyPriorityNV(
 #endif
 
 
+// VK_EXT_cooperative_matrix_maintenance1 is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_cooperative_matrix_maintenance1 1
+#define VK_EXT_COOPERATIVE_MATRIX_MAINTENANCE_1_SPEC_VERSION 1
+#define VK_EXT_COOPERATIVE_MATRIX_MAINTENANCE_1_EXTENSION_NAME "VK_EXT_cooperative_matrix_maintenance1"
+
+typedef enum VkCooperativeMatrixFlagBitsEXT {
+    VK_COOPERATIVE_MATRIX_SATURATING_ACCUMULATION_BIT_EXT = 0x00000001,
+    VK_COOPERATIVE_MATRIX_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkCooperativeMatrixFlagBitsEXT;
+typedef VkFlags VkCooperativeMatrixFlagsEXT;
+typedef struct VkCooperativeMatrixProperties2EXT {
+    VkStructureType       sType;
+    void*                 pNext;
+    uint32_t              MGranularity;
+    uint32_t              NGranularity;
+    uint32_t              KGranularity;
+    VkComponentTypeKHR    AType;
+    VkComponentTypeKHR    BType;
+    VkComponentTypeKHR    CType;
+    VkComponentTypeKHR    ResultType;
+} VkCooperativeMatrixProperties2EXT;
+
+typedef struct VkPhysicalDeviceCooperativeMatrixInfo2EXT {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkScopeKHR                     scope;
+    uint32_t                       invocations;
+    uint32_t                       subgroupSize;
+    VkCooperativeMatrixFlagsEXT    flags;
+} VkPhysicalDeviceCooperativeMatrixInfo2EXT;
+
+typedef struct VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           cooperativeMatrixProperties2;
+    VkBool32           cooperativeMatrixReductions;
+    VkBool32           cooperativeMatrixConversions;
+    VkBool32           cooperativeMatrixPerElementOperations;
+    VkBool32           cooperativeMatrixGetCoordinate;
+} VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceCooperativeMatrixInfo2EXT* pCooperativeMatrixInfo, uint32_t* pPropertyCount, VkCooperativeMatrixProperties2EXT* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixProperties2EXT(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceCooperativeMatrixInfo2EXT* pCooperativeMatrixInfo,
+    uint32_t*                                   pPropertyCount,
+    VkCooperativeMatrixProperties2EXT*          pProperties);
+#endif
+#endif
+
+
 // VK_EXT_shader_subgroup_partitioned is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_shader_subgroup_partitioned 1
 #define VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1

third_party/vulkan/vulkan_enums.hpp

@@ -1847,6 +1847,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     ePhysicalDeviceComputeOccupancyPriorityFeaturesNV         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV,
     ePhysicalDeviceMaintenance11FeaturesKHR                   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR,
     eQueueFamilyOptimalImageTransferGranularityPropertiesKHR  = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR,
+    ePhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_MAINTENANCE_1_FEATURES_EXT,
+    ePhysicalDeviceCooperativeMatrixInfo2EXT                  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_INFO_2_EXT,
+    eCooperativeMatrixProperties2EXT                          = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_2_EXT,
     ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT       = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT,
 #if defined( VK_USE_PLATFORM_UBM_SEC )
     eUbmSurfaceCreateInfoSEC = VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC,
@@ -4907,7 +4910,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     eVulkanScEmulationOnVulkan  = VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN,
     eMesaKosmickrisp            = VK_DRIVER_ID_MESA_KOSMICKRISP,
     eMesaGfxstream              = VK_DRIVER_ID_MESA_GFXSTREAM,
-    eApeSoft                    = VK_DRIVER_ID_APE_SOFT
+    eApeSoft                    = VK_DRIVER_ID_APE_SOFT,
+    eReserved31                 = VK_DRIVER_ID_RESERVED_31
   };
 
   using DriverIdKHR = DriverId;
@@ -10486,6 +10490,25 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     eOpticalFlowCost       = VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_COST_ARM
   };
 
+  //=== VK_EXT_cooperative_matrix_maintenance1 ===
+
+  // wrapper class for enum VkCooperativeMatrixFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixFlagBitsEXT.html
+  enum class CooperativeMatrixFlagBitsEXT : VkCooperativeMatrixFlagsEXT
+  {
+    eSaturatingAccumulation = VK_COOPERATIVE_MATRIX_SATURATING_ACCUMULATION_BIT_EXT
+  };
+
+  // wrapper using for bitmask VkCooperativeMatrixFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixFlagsEXT.html
+  using CooperativeMatrixFlagsEXT = Flags<CooperativeMatrixFlagBitsEXT>;
+
+  template <>
+  struct FlagTraits<CooperativeMatrixFlagBitsEXT>
+  {
+    using WrappedType                                                        = VkCooperativeMatrixFlagBitsEXT;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool                      isBitmask = true;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR CooperativeMatrixFlagsEXT allFlags  = CooperativeMatrixFlagBitsEXT::eSaturatingAccumulation;
+  };
+
 #if defined( VK_USE_PLATFORM_UBM_SEC )
   //=== VK_SEC_ubm_surface ===
 

third_party/vulkan/vulkan_extension_inspection.hpp

@@ -543,6 +543,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
                                                             "VK_EXT_shader_uniform_buffer_unsized_array",
                                                             "VK_NV_compute_occupancy_priority",
                                                             "VK_KHR_maintenance11",
+                                                            "VK_EXT_cooperative_matrix_maintenance1",
                                                             "VK_EXT_shader_subgroup_partitioned",
                                                             "VK_KHR_extended_flags",
                                                             "VK_EXT_shader_ocp_microscaling_types",
@@ -3248,6 +3249,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_cooperative_matrix_maintenance1",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_cooperative_matrix",
+            } } } } },
       { "VK_EXT_shader_subgroup_partitioned",
         { { "VK_VERSION_1_0",
             { {
@@ -4281,7 +4287,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) || ( extension == "VK_ARM_data_graph_optical_flow" ) ||
            ( extension == "VK_EXT_shader_long_vector" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) ||
            ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || ( extension == "VK_NV_compute_occupancy_priority" ) ||
-           ( extension == "VK_KHR_maintenance11" ) || ( extension == "VK_EXT_shader_subgroup_partitioned" ) || ( extension == "VK_KHR_extended_flags" ) ||
+           ( extension == "VK_KHR_maintenance11" ) || ( extension == "VK_EXT_cooperative_matrix_maintenance1" ) ||
+           ( extension == "VK_EXT_shader_subgroup_partitioned" ) || ( extension == "VK_KHR_extended_flags" ) ||
            ( extension == "VK_EXT_shader_ocp_microscaling_types" ) || ( extension == "VK_VALVE_shader_mixed_float_dot_product" ) ||
            ( extension == "VK_SEC_throttle_hint" ) || ( extension == "VK_ARM_data_graph_neural_accelerator_statistics" ) ||
            ( extension == "VK_EXT_primitive_restart_index" ) || ( extension == "VK_EXT_image_tiling_control" ) ||

third_party/vulkan/vulkan_funcs.hpp

@@ -34153,6 +34153,119 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
   }
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
+  //=== VK_EXT_cooperative_matrix_maintenance1 ===
+
+  // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixProperties2EXT, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html
+  template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixProperties2EXT ), bool>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixProperties2EXT(
+    PhysicalDeviceCooperativeMatrixInfo2EXT const * pCooperativeMatrixInfo,
+    uint32_t *                                      pPropertyCount,
+    CooperativeMatrixProperties2EXT *               pProperties,
+    Dispatch const &                                d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    return static_cast<Result>(
+      d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                            reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT const *>( pCooperativeMatrixInfo ),
+                                                            pPropertyCount,
+                                                            reinterpret_cast<VkCooperativeMatrixProperties2EXT *>( pProperties ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixProperties2EXT, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html
+  template <
+    typename CooperativeMatrixProperties2EXTAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename CooperativeMatrixProperties2EXTAllocator::value_type, CooperativeMatrixProperties2EXT>::value, int>::type,
+    typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixProperties2EXT ), bool>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CooperativeMatrixProperties2EXT, CooperativeMatrixProperties2EXTAllocator>>::type
+    PhysicalDevice::getCooperativeMatrixProperties2EXT( PhysicalDeviceCooperativeMatrixInfo2EXT const & cooperativeMatrixInfo, Dispatch const & d ) const
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT &&
+                       "Function <vkGetPhysicalDeviceCooperativeMatrixProperties2EXT> requires <VK_EXT_cooperative_matrix_maintenance1>" );
+#  endif
+
+    std::vector<CooperativeMatrixProperties2EXT, CooperativeMatrixProperties2EXTAllocator> properties;
+    uint32_t                                                                               propertyCount;
+    Result                                                                                 result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                              reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT const *>( &cooperativeMatrixInfo ),
+                                                              &propertyCount,
+                                                              nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>(
+          d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                                reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT const *>( &cooperativeMatrixInfo ),
+                                                                &propertyCount,
+                                                                reinterpret_cast<VkCooperativeMatrixProperties2EXT *>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixProperties2EXT" );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+    if ( propertyCount < properties.size() )
+    {
+      properties.resize( propertyCount );
+    }
+    return detail::createResultValueType( result, std::move( properties ) );
+  }
+
+  // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixProperties2EXT, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html
+  template <
+    typename CooperativeMatrixProperties2EXTAllocator,
+    typename Dispatch,
+    typename std::enable_if<std::is_same<typename CooperativeMatrixProperties2EXTAllocator::value_type, CooperativeMatrixProperties2EXT>::value, int>::type,
+    typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixProperties2EXT ), bool>::type>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CooperativeMatrixProperties2EXT, CooperativeMatrixProperties2EXTAllocator>>::type
+                       PhysicalDevice::getCooperativeMatrixProperties2EXT( PhysicalDeviceCooperativeMatrixInfo2EXT const &  cooperativeMatrixInfo,
+                                                        CooperativeMatrixProperties2EXTAllocator const & cooperativeMatrixProperties2EXTAllocator,
+                                                        Dispatch const &                                 d ) const
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT &&
+                       "Function <vkGetPhysicalDeviceCooperativeMatrixProperties2EXT> requires <VK_EXT_cooperative_matrix_maintenance1>" );
+#  endif
+
+    std::vector<CooperativeMatrixProperties2EXT, CooperativeMatrixProperties2EXTAllocator> properties( cooperativeMatrixProperties2EXTAllocator );
+    uint32_t                                                                               propertyCount;
+    Result                                                                                 result;
+    do
+    {
+      result = static_cast<Result>(
+        d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                              reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT const *>( &cooperativeMatrixInfo ),
+                                                              &propertyCount,
+                                                              nullptr ) );
+      if ( ( result == Result::eSuccess ) && propertyCount )
+      {
+        properties.resize( propertyCount );
+        result = static_cast<Result>(
+          d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
+                                                                reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT const *>( &cooperativeMatrixInfo ),
+                                                                &propertyCount,
+                                                                reinterpret_cast<VkCooperativeMatrixProperties2EXT *>( properties.data() ) ) );
+      }
+    } while ( result == Result::eIncomplete );
+    detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixProperties2EXT" );
+    VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+    if ( propertyCount < properties.size() )
+    {
+      properties.resize( propertyCount );
+    }
+    return detail::createResultValueType( result, std::move( properties ) );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
 #if defined( VK_USE_PLATFORM_UBM_SEC )
   //=== VK_SEC_ubm_surface ===
 

third_party/vulkan/vulkan_handles.hpp

@@ -2443,6 +2443,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
   struct PhysicalDeviceMaintenance11FeaturesKHR;
   struct QueueFamilyOptimalImageTransferGranularityPropertiesKHR;
 
+  //=== VK_EXT_cooperative_matrix_maintenance1 ===
+  struct CooperativeMatrixProperties2EXT;
+  struct PhysicalDeviceCooperativeMatrixInfo2EXT;
+  struct PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT;
+
   //=== VK_EXT_shader_subgroup_partitioned ===
   struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT;
 
@@ -22847,6 +22852,40 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
         Dispatch const & d                                            VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
+    //=== VK_EXT_cooperative_matrix_maintenance1 ===
+
+    // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixProperties2EXT, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html
+    template <typename Dispatch                                                                                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixProperties2EXT ), bool>::type = true>
+    VULKAN_HPP_NODISCARD Result getCooperativeMatrixProperties2EXT( PhysicalDeviceCooperativeMatrixInfo2EXT const * pCooperativeMatrixInfo,
+                                                                    uint32_t *                                      pPropertyCount,
+                                                                    CooperativeMatrixProperties2EXT *               pProperties,
+                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixProperties2EXT, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html
+    template <typename CooperativeMatrixProperties2EXTAllocator = std::allocator<CooperativeMatrixProperties2EXT>,
+              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename CooperativeMatrixProperties2EXTAllocator::value_type, CooperativeMatrixProperties2EXT>::value,
+                                      int>::type                = 0,
+              typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixProperties2EXT ), bool>::type = true>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixProperties2EXT, CooperativeMatrixProperties2EXTAllocator>>::type
+      getCooperativeMatrixProperties2EXT( PhysicalDeviceCooperativeMatrixInfo2EXT const & cooperativeMatrixInfo,
+                                          Dispatch const & d                              VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+    // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixProperties2EXT, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html
+    template <typename CooperativeMatrixProperties2EXTAllocator = std::allocator<CooperativeMatrixProperties2EXT>,
+              typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<std::is_same<typename CooperativeMatrixProperties2EXTAllocator::value_type, CooperativeMatrixProperties2EXT>::value,
+                                      int>::type                = 0,
+              typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixProperties2EXT ), bool>::type = true>
+    VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixProperties2EXT, CooperativeMatrixProperties2EXTAllocator>>::type
+      getCooperativeMatrixProperties2EXT( PhysicalDeviceCooperativeMatrixInfo2EXT const &  cooperativeMatrixInfo,
+                                          CooperativeMatrixProperties2EXTAllocator const & cooperativeMatrixProperties2EXTAllocator,
+                                          Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
 #if defined( VK_USE_PLATFORM_UBM_SEC )
     //=== VK_SEC_ubm_surface ===
 

third_party/vulkan/vulkan_hash.hpp

@@ -3123,6 +3123,25 @@ VULKAN_HPP_EXPORT namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixProperties2EXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixProperties2EXT const & cooperativeMatrixProperties2EXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixProperties2EXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixProperties2EXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixProperties2EXT.MGranularity );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixProperties2EXT.NGranularity );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixProperties2EXT.KGranularity );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixProperties2EXT.AType );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixProperties2EXT.BType );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixProperties2EXT.CType );
+      VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixProperties2EXT.ResultType );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>
   {
@@ -10581,6 +10600,41 @@ VULKAN_HPP_EXPORT namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixInfo2EXT>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixInfo2EXT const & physicalDeviceCooperativeMatrixInfo2EXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixInfo2EXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixInfo2EXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixInfo2EXT.scope );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixInfo2EXT.invocations );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixInfo2EXT.subgroupSize );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixInfo2EXT.flags );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const &
+                              physicalDeviceCooperativeMatrixMaintenance1FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixMaintenance1FeaturesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixMaintenance1FeaturesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixMaintenance1FeaturesEXT.cooperativeMatrixProperties2 );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixMaintenance1FeaturesEXT.cooperativeMatrixReductions );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixMaintenance1FeaturesEXT.cooperativeMatrixConversions );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixMaintenance1FeaturesEXT.cooperativeMatrixPerElementOperations );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixMaintenance1FeaturesEXT.cooperativeMatrixGetCoordinate );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR>
   {

third_party/vulkan/vulkan_raii.hpp

@@ -414,6 +414,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
           vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(
             vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM" ) );
 
+          //=== VK_EXT_cooperative_matrix_maintenance1 ===
+          vkGetPhysicalDeviceCooperativeMatrixProperties2EXT =
+            PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixProperties2EXT" ) );
+
 #  if defined( VK_USE_PLATFORM_UBM_SEC )
           //=== VK_SEC_ubm_surface ===
           vkCreateUbmSurfaceSEC = PFN_vkCreateUbmSurfaceSEC( vkGetInstanceProcAddr( instance, "vkCreateUbmSurfaceSEC" ) );
@@ -733,6 +737,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
         //=== VK_ARM_data_graph_optical_flow ===
         PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM = 0;
 
+        //=== VK_EXT_cooperative_matrix_maintenance1 ===
+        PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT vkGetPhysicalDeviceCooperativeMatrixProperties2EXT = 0;
+
 #  if defined( VK_USE_PLATFORM_UBM_SEC )
         //=== VK_SEC_ubm_surface ===
         PFN_vkCreateUbmSurfaceSEC                        vkCreateUbmSurfaceSEC                        = 0;
@@ -4412,6 +4419,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
                                                            QueueFamilyDataGraphPropertiesARM const &      queueFamilyDataGraphProperties,
                                                            DataGraphOpticalFlowImageFormatInfoARM const & opticalFlowImageFormatInfo ) const;
 
+      //=== VK_EXT_cooperative_matrix_maintenance1 ===
+
+      // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixProperties2EXT, see
+      // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html
+      VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<CooperativeMatrixProperties2EXT>>::type
+        getCooperativeMatrixProperties2EXT( PhysicalDeviceCooperativeMatrixInfo2EXT const & cooperativeMatrixInfo ) const;
+
 #  if defined( VK_USE_PLATFORM_UBM_SEC )
       //=== VK_SEC_ubm_surface ===
 
@@ -30091,6 +30105,45 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
                                                            reinterpret_cast<VkComputeOccupancyPriorityParametersNV const *>( &parameters ) );
     }
 
+    //=== VK_EXT_cooperative_matrix_maintenance1 ===
+
+    // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixProperties2EXT, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html
+    VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<CooperativeMatrixProperties2EXT>>::type
+                         PhysicalDevice::getCooperativeMatrixProperties2EXT( PhysicalDeviceCooperativeMatrixInfo2EXT const & cooperativeMatrixInfo ) const
+    {
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixProperties2EXT &&
+                         "Function <vkGetPhysicalDeviceCooperativeMatrixProperties2EXT> requires <VK_EXT_cooperative_matrix_maintenance1>" );
+
+      std::vector<CooperativeMatrixProperties2EXT> properties;
+      uint32_t                                     propertyCount;
+      Result                                       result;
+      do
+      {
+        result = static_cast<Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixProperties2EXT(
+          static_cast<VkPhysicalDevice>( m_physicalDevice ),
+          reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT const *>( &cooperativeMatrixInfo ),
+          &propertyCount,
+          nullptr ) );
+        if ( ( result == Result::eSuccess ) && propertyCount )
+        {
+          properties.resize( propertyCount );
+          result = static_cast<Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixProperties2EXT(
+            static_cast<VkPhysicalDevice>( m_physicalDevice ),
+            reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT const *>( &cooperativeMatrixInfo ),
+            &propertyCount,
+            reinterpret_cast<VkCooperativeMatrixProperties2EXT *>( properties.data() ) ) );
+        }
+      } while ( result == Result::eIncomplete );
+      VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixProperties2EXT" );
+      VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
+      if ( propertyCount < properties.size() )
+      {
+        properties.resize( propertyCount );
+      }
+      return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) );
+    }
+
 #  if defined( VK_USE_PLATFORM_UBM_SEC )
     //=== VK_SEC_ubm_surface ===
 

third_party/vulkan/vulkan_static_assertions.hpp

@@ -10403,6 +10403,29 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::QueueFam
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueueFamilyOptimalImageTransferGranularityPropertiesKHR>::value,
                           "QueueFamilyOptimalImageTransferGranularityPropertiesKHR is not nothrow_move_constructible!" );
 
+//=== VK_EXT_cooperative_matrix_maintenance1 ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixProperties2EXT ) == sizeof( VkCooperativeMatrixProperties2EXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CooperativeMatrixProperties2EXT>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CooperativeMatrixProperties2EXT>::value,
+                          "CooperativeMatrixProperties2EXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixInfo2EXT ) == sizeof( VkPhysicalDeviceCooperativeMatrixInfo2EXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixInfo2EXT>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixInfo2EXT>::value,
+                          "PhysicalDeviceCooperativeMatrixInfo2EXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT ) ==
+                            sizeof( VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT>::value,
+                          "PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT is not nothrow_move_constructible!" );
+
 //=== VK_EXT_shader_subgroup_partitioned ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT ) ==

third_party/vulkan/vulkan_structs.hpp

@@ -29424,6 +29424,133 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     using Type = CooperativeMatrixFlexibleDimensionsPropertiesNV;
   };
 
+  // wrapper struct for struct VkCooperativeMatrixProperties2EXT, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixProperties2EXT.html
+  struct CooperativeMatrixProperties2EXT
+  {
+    using NativeType = VkCooperativeMatrixProperties2EXT;
+
+    static bool const                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eCooperativeMatrixProperties2EXT;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR CooperativeMatrixProperties2EXT( uint32_t         MGranularity_ = {},
+                                                          uint32_t         NGranularity_ = {},
+                                                          uint32_t         KGranularity_ = {},
+                                                          ComponentTypeKHR AType_        = ComponentTypeKHR::eFloat16,
+                                                          ComponentTypeKHR BType_        = ComponentTypeKHR::eFloat16,
+                                                          ComponentTypeKHR CType_        = ComponentTypeKHR::eFloat16,
+                                                          ComponentTypeKHR ResultType_   = ComponentTypeKHR::eFloat16,
+                                                          void *           pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , MGranularity{ MGranularity_ }
+      , NGranularity{ NGranularity_ }
+      , KGranularity{ KGranularity_ }
+      , AType{ AType_ }
+      , BType{ BType_ }
+      , CType{ CType_ }
+      , ResultType{ ResultType_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR CooperativeMatrixProperties2EXT( CooperativeMatrixProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    CooperativeMatrixProperties2EXT( VkCooperativeMatrixProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
+      : CooperativeMatrixProperties2EXT( *reinterpret_cast<CooperativeMatrixProperties2EXT const *>( &rhs ) )
+    {
+    }
+
+    CooperativeMatrixProperties2EXT & operator=( CooperativeMatrixProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    CooperativeMatrixProperties2EXT & operator=( VkCooperativeMatrixProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<CooperativeMatrixProperties2EXT const *>( &rhs );
+      return *this;
+    }
+
+    operator VkCooperativeMatrixProperties2EXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkCooperativeMatrixProperties2EXT const *>( this );
+    }
+
+    operator VkCooperativeMatrixProperties2EXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkCooperativeMatrixProperties2EXT *>( this );
+    }
+
+    operator VkCooperativeMatrixProperties2EXT const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkCooperativeMatrixProperties2EXT const *>( this );
+    }
+
+    operator VkCooperativeMatrixProperties2EXT *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkCooperativeMatrixProperties2EXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<StructureType const &,
+               void * const &,
+               uint32_t const &,
+               uint32_t const &,
+               uint32_t const &,
+               ComponentTypeKHR const &,
+               ComponentTypeKHR const &,
+               ComponentTypeKHR const &,
+               ComponentTypeKHR const &>
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, MGranularity, NGranularity, KGranularity, AType, BType, CType, ResultType );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( CooperativeMatrixProperties2EXT const & ) const = default;
+#else
+    bool operator==( CooperativeMatrixProperties2EXT 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 );
+#  endif
+    }
+
+    bool operator!=( CooperativeMatrixProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    StructureType    sType        = StructureType::eCooperativeMatrixProperties2EXT;
+    void *           pNext        = {};
+    uint32_t         MGranularity = {};
+    uint32_t         NGranularity = {};
+    uint32_t         KGranularity = {};
+    ComponentTypeKHR AType        = ComponentTypeKHR::eFloat16;
+    ComponentTypeKHR BType        = ComponentTypeKHR::eFloat16;
+    ComponentTypeKHR CType        = ComponentTypeKHR::eFloat16;
+    ComponentTypeKHR ResultType   = ComponentTypeKHR::eFloat16;
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkCooperativeMatrixProperties2EXT>
+  {
+    using Type = CooperativeMatrixProperties2EXT;
+  };
+#endif
+
+  template <>
+  struct CppType<StructureType, StructureType::eCooperativeMatrixProperties2EXT>
+  {
+    using Type = CooperativeMatrixProperties2EXT;
+  };
+
   // wrapper struct for struct VkCooperativeMatrixPropertiesKHR, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixPropertiesKHR.html
   struct CooperativeMatrixPropertiesKHR
@@ -106010,6 +106137,388 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceCooperativeMatrixFeaturesNV;
   };
 
+  // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixInfo2EXT, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixInfo2EXT.html
+  struct PhysicalDeviceCooperativeMatrixInfo2EXT
+  {
+    using NativeType = VkPhysicalDeviceCooperativeMatrixInfo2EXT;
+
+    static bool const                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceCooperativeMatrixInfo2EXT;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixInfo2EXT( ScopeKHR                  scope_        = ScopeKHR::eDevice,
+                                                                  uint32_t                  invocations_  = {},
+                                                                  uint32_t                  subgroupSize_ = {},
+                                                                  CooperativeMatrixFlagsEXT flags_        = {},
+                                                                  void const *              pNext_        = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , scope{ scope_ }
+      , invocations{ invocations_ }
+      , subgroupSize{ subgroupSize_ }
+      , flags{ flags_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixInfo2EXT( PhysicalDeviceCooperativeMatrixInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceCooperativeMatrixInfo2EXT( VkPhysicalDeviceCooperativeMatrixInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceCooperativeMatrixInfo2EXT( *reinterpret_cast<PhysicalDeviceCooperativeMatrixInfo2EXT const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceCooperativeMatrixInfo2EXT & operator=( PhysicalDeviceCooperativeMatrixInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    PhysicalDeviceCooperativeMatrixInfo2EXT & operator=( VkPhysicalDeviceCooperativeMatrixInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<PhysicalDeviceCooperativeMatrixInfo2EXT const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT & setScope( ScopeKHR scope_ ) & VULKAN_HPP_NOEXCEPT
+    {
+      scope = scope_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT && setScope( ScopeKHR scope_ ) && VULKAN_HPP_NOEXCEPT
+    {
+      scope = scope_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT & setInvocations( uint32_t invocations_ ) & VULKAN_HPP_NOEXCEPT
+    {
+      invocations = invocations_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT && setInvocations( uint32_t invocations_ ) && VULKAN_HPP_NOEXCEPT
+    {
+      invocations = invocations_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT & setSubgroupSize( uint32_t subgroupSize_ ) & VULKAN_HPP_NOEXCEPT
+    {
+      subgroupSize = subgroupSize_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT && setSubgroupSize( uint32_t subgroupSize_ ) && VULKAN_HPP_NOEXCEPT
+    {
+      subgroupSize = subgroupSize_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT & setFlags( CooperativeMatrixFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT
+    {
+      flags = flags_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixInfo2EXT && setFlags( CooperativeMatrixFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT
+    {
+      flags = flags_;
+      return std::move( *this );
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
+    operator VkPhysicalDeviceCooperativeMatrixInfo2EXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT const *>( this );
+    }
+
+    operator VkPhysicalDeviceCooperativeMatrixInfo2EXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT *>( this );
+    }
+
+    operator VkPhysicalDeviceCooperativeMatrixInfo2EXT const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT const *>( this );
+    }
+
+    operator VkPhysicalDeviceCooperativeMatrixInfo2EXT *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixInfo2EXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<StructureType const &, void const * const &, ScopeKHR const &, uint32_t const &, uint32_t const &, CooperativeMatrixFlagsEXT const &>
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, scope, invocations, subgroupSize, flags );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceCooperativeMatrixInfo2EXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceCooperativeMatrixInfo2EXT 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 ) && ( scope == rhs.scope ) && ( invocations == rhs.invocations ) &&
+             ( subgroupSize == rhs.subgroupSize ) && ( flags == rhs.flags );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceCooperativeMatrixInfo2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    StructureType             sType        = StructureType::ePhysicalDeviceCooperativeMatrixInfo2EXT;
+    void const *              pNext        = {};
+    ScopeKHR                  scope        = ScopeKHR::eDevice;
+    uint32_t                  invocations  = {};
+    uint32_t                  subgroupSize = {};
+    CooperativeMatrixFlagsEXT flags        = {};
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkPhysicalDeviceCooperativeMatrixInfo2EXT>
+  {
+    using Type = PhysicalDeviceCooperativeMatrixInfo2EXT;
+  };
+#endif
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceCooperativeMatrixInfo2EXT>
+  {
+    using Type = PhysicalDeviceCooperativeMatrixInfo2EXT;
+  };
+
+  // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT.html
+  struct PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT
+  {
+    using NativeType = VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT;
+
+    static bool const                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT( Bool32 cooperativeMatrixProperties2_          = {},
+                                                                                 Bool32 cooperativeMatrixReductions_           = {},
+                                                                                 Bool32 cooperativeMatrixConversions_          = {},
+                                                                                 Bool32 cooperativeMatrixPerElementOperations_ = {},
+                                                                                 Bool32 cooperativeMatrixGetCoordinate_        = {},
+                                                                                 void * pNext_                                 = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , cooperativeMatrixProperties2{ cooperativeMatrixProperties2_ }
+      , cooperativeMatrixReductions{ cooperativeMatrixReductions_ }
+      , cooperativeMatrixConversions{ cooperativeMatrixConversions_ }
+      , cooperativeMatrixPerElementOperations{ cooperativeMatrixPerElementOperations_ }
+      , cooperativeMatrixGetCoordinate{ cooperativeMatrixGetCoordinate_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT( PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const & rhs )
+      VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT( VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT( *reinterpret_cast<PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const *>( &rhs ) )
+    {
+    }
+
+    PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &
+      operator=( PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &
+      operator=( VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT & setCooperativeMatrixProperties2( Bool32 cooperativeMatrixProperties2_ ) &
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixProperties2 = cooperativeMatrixProperties2_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT && setCooperativeMatrixProperties2( Bool32 cooperativeMatrixProperties2_ ) &&
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixProperties2 = cooperativeMatrixProperties2_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT & setCooperativeMatrixReductions( Bool32 cooperativeMatrixReductions_ ) &
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixReductions = cooperativeMatrixReductions_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT && setCooperativeMatrixReductions( Bool32 cooperativeMatrixReductions_ ) &&
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixReductions = cooperativeMatrixReductions_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT & setCooperativeMatrixConversions( Bool32 cooperativeMatrixConversions_ ) &
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixConversions = cooperativeMatrixConversions_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT && setCooperativeMatrixConversions( Bool32 cooperativeMatrixConversions_ ) &&
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixConversions = cooperativeMatrixConversions_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &
+      setCooperativeMatrixPerElementOperations( Bool32 cooperativeMatrixPerElementOperations_ ) &
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixPerElementOperations = cooperativeMatrixPerElementOperations_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &&
+      setCooperativeMatrixPerElementOperations( Bool32 cooperativeMatrixPerElementOperations_ ) &&
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixPerElementOperations = cooperativeMatrixPerElementOperations_;
+      return std::move( *this );
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &
+      setCooperativeMatrixGetCoordinate( Bool32 cooperativeMatrixGetCoordinate_ ) &
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixGetCoordinate = cooperativeMatrixGetCoordinate_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &&
+      setCooperativeMatrixGetCoordinate( Bool32 cooperativeMatrixGetCoordinate_ ) &&
+      VULKAN_HPP_NOEXCEPT
+    {
+      cooperativeMatrixGetCoordinate = cooperativeMatrixGetCoordinate_;
+      return std::move( *this );
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
+    operator VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const *>( this );
+    }
+
+    operator VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT *>( this );
+    }
+
+    operator VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const *>( this );
+    }
+
+    operator VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<StructureType const &, void * const &, Bool32 const &, Bool32 const &, Bool32 const &, Bool32 const &, Bool32 const &>
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType,
+                       pNext,
+                       cooperativeMatrixProperties2,
+                       cooperativeMatrixReductions,
+                       cooperativeMatrixConversions,
+                       cooperativeMatrixPerElementOperations,
+                       cooperativeMatrixGetCoordinate );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT 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 ) && ( cooperativeMatrixProperties2 == rhs.cooperativeMatrixProperties2 ) &&
+             ( cooperativeMatrixReductions == rhs.cooperativeMatrixReductions ) && ( cooperativeMatrixConversions == rhs.cooperativeMatrixConversions ) &&
+             ( cooperativeMatrixPerElementOperations == rhs.cooperativeMatrixPerElementOperations ) &&
+             ( cooperativeMatrixGetCoordinate == rhs.cooperativeMatrixGetCoordinate );
+#  endif
+    }
+
+    bool operator!=( PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    StructureType sType                                 = StructureType::ePhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT;
+    void *        pNext                                 = {};
+    Bool32        cooperativeMatrixProperties2          = {};
+    Bool32        cooperativeMatrixReductions           = {};
+    Bool32        cooperativeMatrixConversions          = {};
+    Bool32        cooperativeMatrixPerElementOperations = {};
+    Bool32        cooperativeMatrixGetCoordinate        = {};
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT>
+  {
+    using Type = PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT;
+  };
+#endif
+
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT>
+  {
+    using Type = PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT;
+  };
+
   // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesKHR.html
   struct PhysicalDeviceCooperativeMatrixPropertiesKHR

third_party/vulkan/vulkan_to_string.hpp

@@ -4653,6 +4653,21 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     return result;
   }
 
+  //=== VK_EXT_cooperative_matrix_maintenance1 ===
+
+  VULKAN_HPP_INLINE std::string to_string( CooperativeMatrixFlagsEXT value )
+  {
+    std::string result = "{";
+    if ( value & CooperativeMatrixFlagBitsEXT::eSaturatingAccumulation )
+      result += " SaturatingAccumulation |";
+
+    if ( result.size() > 1 )
+      result.back() = '}';
+    else
+      result = "{}";
+    return result;
+  }
+
 #if defined( VK_USE_PLATFORM_UBM_SEC )
   //=== VK_SEC_ubm_surface ===
 
@@ -6161,6 +6176,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceComputeOccupancyPriorityFeaturesNV        : return "PhysicalDeviceComputeOccupancyPriorityFeaturesNV";
       case StructureType::ePhysicalDeviceMaintenance11FeaturesKHR                  : return "PhysicalDeviceMaintenance11FeaturesKHR";
       case StructureType::eQueueFamilyOptimalImageTransferGranularityPropertiesKHR : return "QueueFamilyOptimalImageTransferGranularityPropertiesKHR";
+      case StructureType::ePhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT  : return "PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT";
+      case StructureType::ePhysicalDeviceCooperativeMatrixInfo2EXT                 : return "PhysicalDeviceCooperativeMatrixInfo2EXT";
+      case StructureType::eCooperativeMatrixProperties2EXT                         : return "CooperativeMatrixProperties2EXT";
       case StructureType::ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT      : return "PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT";
 #if defined( VK_USE_PLATFORM_UBM_SEC )
       case StructureType::eUbmSurfaceCreateInfoSEC: return "UbmSurfaceCreateInfoSEC";
@@ -8236,6 +8254,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
       case DriverId::eMesaKosmickrisp          : return "MesaKosmickrisp";
       case DriverId::eMesaGfxstream            : return "MesaGfxstream";
       case DriverId::eApeSoft                  : return "ApeSoft";
+      case DriverId::eReserved31               : return "Reserved31";
       default                                  : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -11915,6 +11934,17 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  //=== VK_EXT_cooperative_matrix_maintenance1 ===
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CooperativeMatrixFlagBitsEXT value )
+  {
+    switch ( value )
+    {
+      case CooperativeMatrixFlagBitsEXT::eSaturatingAccumulation: return "SaturatingAccumulation";
+      default                                                   : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
+    }
+  }
+
 #if defined( VK_USE_PLATFORM_UBM_SEC )
   //=== VK_SEC_ubm_surface ===