yuzu/Vulkan-Headers
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Headers synced 2024-11-21 06:26:00 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Update for Vulkan-Docs 1.3.300
Some checks failed
ci / cmake-unix (3.15, macos-latest) (push) Has been cancelled
Details
ci / cmake-unix (3.15, ubuntu-latest) (push) Has been cancelled
Details
ci / cmake-unix (latest, macos-latest) (push) Has been cancelled
Details
ci / cmake-unix (latest, ubuntu-latest) (push) Has been cancelled
Details
ci / cmake-windows (3.15) (push) Has been cancelled
Details
ci / cmake-windows (latest) (push) Has been cancelled
Details
ci / windows_clang (clang) (push) Has been cancelled
Details
ci / windows_clang (clang-cl) (push) Has been cancelled
Details
ci / reuse (push) Has been cancelled
Details

Browse source
This commit is contained in:
Jon Leech 2024-10-25 06:46:48 -07:00 committed by Jon Leech
parent e271cfd480
commit ab1ea9059d
15 changed files with 2052 additions and 940 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
include/vulkan/vulkan.cppm
View file

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

49
include/vulkan/vulkan.hpp
View file

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

54
include/vulkan/vulkan_core.h
View file

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

5
include/vulkan/vulkan_enums.hpp
View file

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

12
include/vulkan/vulkan_extension_inspection.hpp
View file

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

550
include/vulkan/vulkan_funcs.hpp
View file

File diff suppressed because it is too large Load diff

472
include/vulkan/vulkan_handles.hpp
View file

File diff suppressed because it is too large Load diff

59
include/vulkan/vulkan_hash.hpp
View file

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

48
include/vulkan/vulkan_raii.hpp
View file

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

25
include/vulkan/vulkan_static_assertions.hpp
View file

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

402
include/vulkan/vulkan_structs.hpp
View file

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

3
include/vulkan/vulkan_to_string.hpp
View file

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

4
registry/parse_dependency.py
View file

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

1073
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

211
registry/vk.xml
View file

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