From 1cc7e2e2ce2c4b2f52e16ccd63773c10a229309b Mon Sep 17 00:00:00 2001 From: Jeff Date: Sun, 9 Aug 2026 14:12:37 +0200 Subject: [PATCH] update dependencies (#242) Automated changes by [create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action Co-authored-by: kbJeff-8 --- third_party/vulkan/vulkan.cppm | 5 +- third_party/vulkan/vulkan.hpp | 51 +- third_party/vulkan/vulkan_core.h | 60 ++- third_party/vulkan/vulkan_enums.hpp | 25 +- .../vulkan/vulkan_extension_inspection.hpp | 9 +- third_party/vulkan/vulkan_funcs.hpp | 113 ++++ third_party/vulkan/vulkan_handles.hpp | 39 ++ third_party/vulkan/vulkan_hash.hpp | 54 ++ third_party/vulkan/vulkan_raii.hpp | 53 ++ .../vulkan/vulkan_static_assertions.hpp | 23 + third_party/vulkan/vulkan_structs.hpp | 509 ++++++++++++++++++ third_party/vulkan/vulkan_to_string.hpp | 30 ++ 12 files changed, 962 insertions(+), 9 deletions(-) diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index bb9062a..feb2a3b 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/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; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index 4aadc13..ba33e81 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/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 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 + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_shader_subgroup_partitioned === template <> struct StructExtends @@ -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" ) ); diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index a26833a..dca67dd 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/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 diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index dc97042..f960853 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/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; + + template <> + struct FlagTraits + { + 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 === diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index 2a69aa3..697bd2f 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/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" ) || diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index 086d2b7..9c65f2a 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/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 ::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( + d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast( m_physicalDevice ), + reinterpret_cast( pCooperativeMatrixInfo ), + pPropertyCount, + reinterpret_cast( 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::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::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 requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast( m_physicalDevice ), + reinterpret_cast( &cooperativeMatrixInfo ), + &propertyCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( + d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast( m_physicalDevice ), + reinterpret_cast( &cooperativeMatrixInfo ), + &propertyCount, + reinterpret_cast( 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::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::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 requires " ); +# endif + + std::vector properties( cooperativeMatrixProperties2EXTAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast( m_physicalDevice ), + reinterpret_cast( &cooperativeMatrixInfo ), + &propertyCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( + d.vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( static_cast( m_physicalDevice ), + reinterpret_cast( &cooperativeMatrixInfo ), + &propertyCount, + reinterpret_cast( 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 === diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index 18f7dee..aa90842 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/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 ::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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::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 === diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index ca37481..6f3fa8c 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -3123,6 +3123,25 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + 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 { @@ -10581,6 +10600,41 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + 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 + { + 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 { diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index 933b6f2..56ab3b3 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/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>::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( ¶meters ) ); } + //=== 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>::type + PhysicalDevice::getCooperativeMatrixProperties2EXT( PhysicalDeviceCooperativeMatrixInfo2EXT const & cooperativeMatrixInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixProperties2EXT && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( + static_cast( m_physicalDevice ), + reinterpret_cast( &cooperativeMatrixInfo ), + &propertyCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixProperties2EXT( + static_cast( m_physicalDevice ), + reinterpret_cast( &cooperativeMatrixInfo ), + &propertyCount, + reinterpret_cast( 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 === diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index 84243dd..4718049 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -10403,6 +10403,29 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::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::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::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::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::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::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT is not nothrow_move_constructible!" ); + //=== VK_EXT_shader_subgroup_partitioned === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT ) == diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index a5e1b67..a5854f1 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/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( &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( &rhs ); + return *this; + } + + operator VkCooperativeMatrixProperties2EXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeMatrixProperties2EXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeMatrixProperties2EXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCooperativeMatrixProperties2EXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + 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 + { + using Type = CooperativeMatrixProperties2EXT; + }; +#endif + + template <> + struct CppType + { + 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( &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( &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( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixInfo2EXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixInfo2EXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixInfo2EXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + 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 + { + using Type = PhysicalDeviceCooperativeMatrixInfo2EXT; + }; +#endif + + template <> + struct CppType + { + 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( &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( &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( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + 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 + { + using Type = PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT; + }; + // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesKHR.html struct PhysicalDeviceCooperativeMatrixPropertiesKHR diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index 2f1d644..194ea1d 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/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( 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( value ) ) + " )"; + } + } + #if defined( VK_USE_PLATFORM_UBM_SEC ) //=== VK_SEC_ubm_surface ===