BeeEngine/vulkan-headers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update for Vulkan-Docs 1.4.332

Browse source
This commit is contained in:
Jon Leech 2025-11-07 01:52:58 +00:00 • committed by Jon Leech
parent 766aaabe57
commit 3dda5a1a87
14 changed files with 1321 additions and 361 deletions
Download patch file Download diff file Expand all files Collapse all files

31
include/vulkan/vulkan.cppm
View file

@ -18,11 +18,7 @@ module;
"To silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n\n" \
"For feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues"
# if defined( __clang__ ) || defined( __GNUC__ ) || defined( __GNUG__ )
_Pragma( VULKAN_HPP_STRINGIFY( GCC warning VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) )
# elif defined( _MSC_VER )
_Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LINE__ ) "): warning: " VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) ) )
# endif
VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING )
#endif
#include <vulkan/vulkan.hpp>
@ -32,8 +28,8 @@ _Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LIN
#include <vulkan/vulkan_raii.hpp>
#include <vulkan/vulkan_shared.hpp>
export module vulkan_hpp;
export import VULKAN_HPP_STD_MODULE;
export module vulkan_hpp;
export import std.compat;
export namespace VULKAN_HPP_NAMESPACE
{
@ -1052,6 +1048,9 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagBitsARM;
using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsARM;
//=== VK_QCOM_data_graph_model ===
using VULKAN_HPP_NAMESPACE::DataGraphModelCacheTypeQCOM;
//=== VK_KHR_maintenance10 ===
using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagBitsKHR;
using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsKHR;
@ -2979,6 +2978,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingSpecVersion;
//=== VK_QCOM_data_graph_model ===
using VULKAN_HPP_NAMESPACE::DataGraphModelToolchainVersionLengthQCOM;
using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelExtensionName;
using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelSpecVersion;
//=== VK_KHR_maintenance10 ===
using VULKAN_HPP_NAMESPACE::KHRMaintenance10ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRMaintenance10SpecVersion;
@ -5278,6 +5282,11 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_64bit_indexing ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT;
//=== VK_QCOM_data_graph_model ===
using VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM;
using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM;
//=== VK_KHR_maintenance10 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR;
@ -9339,6 +9348,14 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT>;
//=== VK_QCOM_data_graph_model ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>;
//=== VK_KHR_maintenance10 ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR>;

39
include/vulkan/vulkan.hpp
View file

@ -38,7 +38,7 @@
# include <cassert>
# include <cstdlib>
# include <cstring>
import VULKAN_HPP_STD_MODULE;
import std.compat;
#endif
#include <vulkan/vulkan.h>
@ -58,7 +58,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif
#endif
static_assert( VK_HEADER_VERSION == 331, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 332, "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)
@ -7614,6 +7614,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_partitioned_acceleration_structure ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t PartitionedAccelerationStructurePartitionIndexGlobalNV = VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV;
//=== VK_QCOM_data_graph_model ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t DataGraphModelToolchainVersionLengthQCOM = VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM;
//========================
//=== CONSTEXPR VALUEs ===
//========================
@ -9530,6 +9533,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingExtensionName = VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingSpecVersion = VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION;
//=== VK_QCOM_data_graph_model ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelExtensionName = VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelSpecVersion = VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION;
//=== VK_KHR_maintenance10 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10ExtensionName = VK_KHR_MAINTENANCE_10_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10SpecVersion = VK_KHR_MAINTENANCE_10_SPEC_VERSION;
@ -19702,6 +19709,34 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_QCOM_data_graph_model ===
template <>
struct StructExtends<DataGraphPipelineBuiltinModelCreateInfoQCOM, DataGraphPipelineCreateInfoARM>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDataGraphModelFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDataGraphModelFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_maintenance10 ===
template <>
struct StructExtends<PhysicalDeviceMaintenance10FeaturesKHR, PhysicalDeviceFeatures2>

45
include/vulkan/vulkan_core.h
View file

@ -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 331
#define VK_HEADER_VERSION 332
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1358,6 +1358,8 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR = 1000361000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT = 1000627000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM = 1000629000,
VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM = 1000629001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR = 1000630000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR = 1000630001,
VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR = 1000630002,
@ -2182,6 +2184,7 @@ typedef enum VkIndexType {
typedef enum VkPipelineCacheHeaderVersion {
VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM = 1000629000,
VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
} VkPipelineCacheHeaderVersion;
@ -21260,7 +21263,7 @@ typedef void (VKAPI_PTR *PFN_vkDestroyTensorViewARM)(VkDevice device, VkTensorVi
typedef void (VKAPI_PTR *PFN_vkGetTensorMemoryRequirementsARM)(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements);
typedef VkResult (VKAPI_PTR *PFN_vkBindTensorMemoryARM)(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos);
typedef void (VKAPI_PTR *PFN_vkGetDeviceTensorMemoryRequirementsARM)(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements);
typedef void (VKAPI_PTR *PFN_vkCmdCopyTensorARM)(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo);
typedef void (VKAPI_PTR *PFN_vkCmdCopyTensorARM)(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo);
typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties);
typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData);
typedef VkResult (VKAPI_PTR *PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData);
@ -21320,7 +21323,7 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM(
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdCopyTensorARM(
VkCommandBuffer commandBuffer,
const VkCopyTensorInfoARM* pCopyTensorInfo);
const VkCopyTensorInfoARM* pCopyTensorInfo);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
@ -22228,11 +22231,15 @@ typedef enum VkDataGraphPipelinePropertyARM {
typedef enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM {
VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM = 0,
VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM = 1000629000,
VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM = 1000629001,
VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF
} VkPhysicalDeviceDataGraphProcessingEngineTypeARM;
typedef enum VkPhysicalDeviceDataGraphOperationTypeARM {
VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0,
VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM = 1000629000,
VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM = 1000629001,
VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF
} VkPhysicalDeviceDataGraphOperationTypeARM;
typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM;
@ -23890,6 +23897,38 @@ typedef struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT {
// VK_QCOM_data_graph_model is a preprocessor guard. Do not pass it to API calls.
#define VK_QCOM_data_graph_model 1
#define VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM 3U
#define VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION 1
#define VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME "VK_QCOM_data_graph_model"
typedef enum VkDataGraphModelCacheTypeQCOM {
VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM = 0,
VK_DATA_GRAPH_MODEL_CACHE_TYPE_MAX_ENUM_QCOM = 0x7FFFFFFF
} VkDataGraphModelCacheTypeQCOM;
typedef struct VkPipelineCacheHeaderVersionDataGraphQCOM {
uint32_t headerSize;
VkPipelineCacheHeaderVersion headerVersion;
VkDataGraphModelCacheTypeQCOM cacheType;
uint32_t cacheVersion;
uint32_t toolchainVersion[VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM];
} VkPipelineCacheHeaderVersionDataGraphQCOM;
typedef struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM {
VkStructureType sType;
const void* pNext;
const VkPhysicalDeviceDataGraphOperationSupportARM* pOperation;
} VkDataGraphPipelineBuiltinModelCreateInfoQCOM;
typedef struct VkPhysicalDeviceDataGraphModelFeaturesQCOM {
VkStructureType sType;
const void* pNext;
VkBool32 dataGraphModel;
} VkPhysicalDeviceDataGraphModelFeaturesQCOM;
// VK_SEC_pipeline_cache_incremental_mode is a preprocessor guard. Do not pass it to API calls.
#define VK_SEC_pipeline_cache_incremental_mode 1
#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION 1

21
include/vulkan/vulkan_enums.hpp
View file

@ -1733,6 +1733,8 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR,
ePhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT,
ePhysicalDeviceShader64BitIndexingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT,
ePhysicalDeviceDataGraphModelFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM,
eDataGraphPipelineBuiltinModelCreateInfoQCOM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM,
ePhysicalDeviceMaintenance10FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR,
ePhysicalDeviceMaintenance10PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR,
eRenderingAttachmentFlagsInfoKHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR,
@ -3191,7 +3193,8 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html
enum class PipelineCacheHeaderVersion
{
eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
eDataGraphQCOM = VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM
};
// wrapper class for enum VkEventCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateFlagBits.html
@ -8805,14 +8808,18 @@ namespace VULKAN_HPP_NAMESPACE
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineTypeARM.html
enum class PhysicalDeviceDataGraphProcessingEngineTypeARM
{
eDefault = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM
eDefault = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM,
eNeuralQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM,
eComputeQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM
};
// wrapper class for enum VkPhysicalDeviceDataGraphOperationTypeARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationTypeARM.html
enum class PhysicalDeviceDataGraphOperationTypeARM
{
eSpirvExtendedInstructionSet = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM
eSpirvExtendedInstructionSet = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM,
eNeuralModelQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM,
eBuiltinModelQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM
};
//=== VK_KHR_video_encode_av1 ===
@ -9405,6 +9412,14 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsARM allFlags = {};
};
//=== VK_QCOM_data_graph_model ===
// wrapper class for enum VkDataGraphModelCacheTypeQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphModelCacheTypeQCOM.html
enum class DataGraphModelCacheTypeQCOM
{
eGenericBinary = VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM
};
//=== VK_KHR_maintenance10 ===
// wrapper class for enum VkRenderingAttachmentFlagBitsKHR, see

150
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -508,6 +508,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_zero_initialize_device_memory",
"VK_KHR_present_mode_fifo_latest_ready",
"VK_EXT_shader_64bit_indexing",
"VK_QCOM_data_graph_model",
"VK_KHR_maintenance10",
"VK_SEC_pipeline_cache_incremental_mode",
"VK_EXT_shader_uniform_buffer_unsized_array" };
@ -1782,7 +1783,17 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_ENABLE_BETA_EXTENSIONS )
,
{ "VK_NV_cuda_kernel_launch",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } }
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
,
{ "VK_QCOM_tile_shading",
{ { "VK_VERSION_1_0",
{ {
@ -2059,6 +2070,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_frame_boundary",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_multisampled_render_to_single_sampled",
{ { "VK_VERSION_1_0",
{ {
@ -2179,6 +2196,12 @@ namespace VULKAN_HPP_NAMESPACE
} } } } },
{ "VK_KHR_maintenance4", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_ARM_shader_core_properties", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_shader_subgroup_rotate",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_ARM_scheduling_controls",
{ { "VK_VERSION_1_0",
{ {
@ -2382,7 +2405,13 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_dynamic_rendering",
} } },
{ "VK_VERSION_1_3", { {} } } } }
{ "VK_VERSION_1_3", { {} } } } },
{ "VK_AMD_anti_lag",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_ENABLE_BETA_EXTENSIONS )
,
{ "VK_AMDX_dense_geometry_format",
@ -2476,6 +2505,18 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_ray_tracing_pipeline",
} } } } },
{ "VK_NV_cooperative_vector",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_extended_sparse_address_space",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_mutable_descriptor_type",
{ { "VK_VERSION_1_0",
{ {
@ -2539,6 +2580,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_deferred_host_operations",
"VK_KHR_maintenance5",
} } } } },
{ "VK_QCOM_multiview_per_view_render_areas",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_compute_shader_derivatives",
{ { "VK_VERSION_1_0",
{ {
@ -2581,6 +2628,12 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_EXT_filter_cubic",
} } } } },
{ "VK_QCOM_ycbcr_degamma",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_QCOM_filter_cubic_clamp",
{ { "VK_VERSION_1_0",
{ {
@ -2607,6 +2660,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_unified_image_layouts",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_shader_float_controls2",
{ { "VK_VERSION_1_1",
{ {
@ -2701,7 +2760,49 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_video_encode_queue",
} } } } },
{ "VK_NV_raw_access_chains",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_shader_relaxed_extended_instruction",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_command_buffer_inheritance",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_shader_atomic_float16_vector",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_shader_replicated_composites",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_shader_float8",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_ray_tracing_validation",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_cluster_acceleration_structure",
{ { "VK_VERSION_1_0",
{ {
@ -2730,6 +2831,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_shader_fma",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_depth_clamp_control",
{ { "VK_VERSION_1_0",
{ {
@ -2806,6 +2913,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_ARM_format_pack",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VALVE_fragment_density_map_layered",
{ { "VK_VERSION_1_0",
{ {
@ -2821,7 +2934,17 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_ENABLE_BETA_EXTENSIONS )
,
{ "VK_NV_present_metering",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } }
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
,
{ "VK_EXT_fragment_density_map_offset",
{ { "VK_VERSION_1_0",
{ {
@ -2862,7 +2985,24 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_QCOM_data_graph_model",
{ { "VK_VERSION_1_0",
{ {
"VK_ARM_data_graph",
} } } } },
{ "VK_KHR_maintenance10",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_SEC_pipeline_cache_incremental_mode",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_shader_uniform_buffer_unsized_array",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
@ -3813,8 +3953,8 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|| ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) ||
( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) ||
( extension == "VK_KHR_maintenance10" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) ||
( extension == "VK_EXT_shader_uniform_buffer_unsized_array" );
( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) ||
( extension == "VK_SEC_pipeline_cache_incremental_mode" ) || ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

5
include/vulkan/vulkan_handles.hpp
View file

@ -2247,6 +2247,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_64bit_indexing ===
struct PhysicalDeviceShader64BitIndexingFeaturesEXT;
//=== VK_QCOM_data_graph_model ===
struct PipelineCacheHeaderVersionDataGraphQCOM;
struct DataGraphPipelineBuiltinModelCreateInfoQCOM;
struct PhysicalDeviceDataGraphModelFeaturesQCOM;
//=== VK_KHR_maintenance10 ===
struct PhysicalDeviceMaintenance10FeaturesKHR;
struct PhysicalDeviceMaintenance10PropertiesKHR;

65
include/vulkan/vulkan_hash.hpp
View file

@ -3442,6 +3442,37 @@ namespace std
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM const & physicalDeviceDataGraphOperationSupportARM ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.operationType );
for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.name[i] );
}
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.version );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM const & dataGraphPipelineBuiltinModelCreateInfoQCOM ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pOperation );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM>
{
@ -9672,18 +9703,15 @@ namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM const & physicalDeviceDataGraphOperationSupportARM ) const
VULKAN_HPP_NOEXCEPT
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM const & physicalDeviceDataGraphModelFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.operationType );
for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.name[i] );
}
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.version );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.dataGraphModel );
return seed;
}
};
@ -15423,6 +15451,25 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM const & pipelineCacheHeaderVersionDataGraphQCOM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerSize );
VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerVersion );
VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheType );
VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheVersion );
for ( size_t i = 0; i < VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.toolchainVersion[i] );
}
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
{

20
include/vulkan/vulkan_hpp_macros.hpp
View file

@ -35,6 +35,18 @@
# include <ciso646>
#endif
#define VULKAN_HPP_STRINGIFY2( text ) #text
#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
#if defined( __clang__ ) || defined( __GNUC__ ) || defined( __GNUG__ )
# define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( GCC warning text ) )
#elif defined( _MSC_VER )
# define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LINE__ ) "): warning: " text ) ) )
#else
# define VULKAN_HPP_COMPILE_WARNING( text )
#endif
#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
# define VULKAN_HPP_NO_SMART_HANDLE
@ -87,8 +99,8 @@
# define VULKAN_HPP_SUPPORT_SPAN
#endif
#if !defined( VULKAN_HPP_STD_MODULE ) && defined( __cpp_modules ) && defined( __cpp_lib_modules )
# define VULKAN_HPP_STD_MODULE std.compat
#if defined( VULKAN_HPP_CXX_MODULE ) && !( defined( __cpp_modules ) && defined( __cpp_lib_modules ) )
VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ named modules and the standard library module." )
#endif
#ifndef VK_USE_64_BIT_PTR_DEFINES
@ -225,10 +237,6 @@
# define VULKAN_HPP_NAMESPACE vk
#endif
#define VULKAN_HPP_STRINGIFY2( text ) #text
#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
# if defined( VK_NO_PROTOTYPES )
# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1

2
include/vulkan/vulkan_ohos.h
View file

@ -22,7 +22,7 @@ extern "C" {
// VK_OHOS_external_memory is a preprocessor guard. Do not pass it to API calls.
#define VK_OHOS_external_memory 1
struct OH_NativeBuffer;
#define VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION 2
#define VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION 1
#define VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME "VK_OHOS_external_memory"
typedef struct VkNativeBufferUsageOHOS {
VkStructureType sType;

24
include/vulkan/vulkan_static_assertions.hpp
View file

@ -9423,6 +9423,30 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT>::value,
"PhysicalDeviceShader64BitIndexingFeaturesEXT is not nothrow_move_constructible!" );
//=== VK_QCOM_data_graph_model ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM ) == sizeof( VkPipelineCacheHeaderVersionDataGraphQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>::value,
"PipelineCacheHeaderVersionDataGraphQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM ) ==
sizeof( VkDataGraphPipelineBuiltinModelCreateInfoQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>::value,
"DataGraphPipelineBuiltinModelCreateInfoQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM ) == sizeof( VkPhysicalDeviceDataGraphModelFeaturesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>::value,
"PhysicalDeviceDataGraphModelFeaturesQCOM is not nothrow_move_constructible!" );
//=== VK_KHR_maintenance10 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance10FeaturesKHR ),

603
include/vulkan/vulkan_structs.hpp
View file

@ -28354,6 +28354,269 @@ namespace VULKAN_HPP_NAMESPACE
};
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
// wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html
struct PhysicalDeviceDataGraphOperationSupportARM
{
using NativeType = VkPhysicalDeviceDataGraphOperationSupportARM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM(
PhysicalDeviceDataGraphOperationTypeARM operationType_ = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet,
std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const & name_ = {},
uint32_t version_ = {} ) VULKAN_HPP_NOEXCEPT
: operationType{ operationType_ }
, name{ name_ }
, version{ version_ }
{
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceDataGraphOperationSupportARM( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceDataGraphOperationSupportARM( *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs ) )
{
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationTypeARM operationType_, std::string const & name_, uint32_t version_ = {} )
: operationType( operationType_ ), version( version_ )
{
VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
# if defined( _WIN32 )
strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
# else
strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
# endif
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
PhysicalDeviceDataGraphOperationSupportARM & operator=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceDataGraphOperationSupportARM & operator=( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) VULKAN_HPP_NOEXCEPT
{
operationType = operationType_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
setName( std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name_ ) VULKAN_HPP_NOEXCEPT
{
name = name_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
PhysicalDeviceDataGraphOperationSupportARM & setName( std::string const & name_ ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
# if defined( _WIN32 )
strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
# else
strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
# endif
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setVersion( uint32_t version_ ) VULKAN_HPP_NOEXCEPT
{
version = version_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceDataGraphOperationSupportARM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
}
operator VkPhysicalDeviceDataGraphOperationSupportARM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
}
operator VkPhysicalDeviceDataGraphOperationSupportARM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
}
operator VkPhysicalDeviceDataGraphOperationSupportARM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<PhysicalDeviceDataGraphOperationTypeARM const &,
ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const &,
uint32_t const &>
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( operationType, name, version );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
std::strong_ordering operator<=>( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
if ( auto cmp = operationType <=> rhs.operationType; cmp != 0 )
return cmp;
if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 )
return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
if ( auto cmp = version <=> rhs.version; cmp != 0 )
return cmp;
return std::strong_ordering::equivalent;
}
#endif
bool operator==( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( operationType == rhs.operationType ) && ( strcmp( name, rhs.name ) == 0 ) && ( version == rhs.version );
}
bool operator!=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
PhysicalDeviceDataGraphOperationTypeARM operationType = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet;
ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name = {};
uint32_t version = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDeviceDataGraphOperationSupportARM>
{
using Type = PhysicalDeviceDataGraphOperationSupportARM;
};
#endif
// wrapper struct for struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineBuiltinModelCreateInfoQCOM.html
struct DataGraphPipelineBuiltinModelCreateInfoQCOM
{
using NativeType = VkDataGraphPipelineBuiltinModelCreateInfoQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, pOperation{ pOperation_ }
{
}
VULKAN_HPP_CONSTEXPR_14
DataGraphPipelineBuiltinModelCreateInfoQCOM( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
DataGraphPipelineBuiltinModelCreateInfoQCOM( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: DataGraphPipelineBuiltinModelCreateInfoQCOM( *reinterpret_cast<DataGraphPipelineBuiltinModelCreateInfoQCOM const *>( &rhs ) )
{
}
DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<DataGraphPipelineBuiltinModelCreateInfoQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM &
setPOperation( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ ) VULKAN_HPP_NOEXCEPT
{
pOperation = pOperation_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
}
operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
}
operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
}
operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, const void * const &, const PhysicalDeviceDataGraphOperationSupportARM * const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, pOperation );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DataGraphPipelineBuiltinModelCreateInfoQCOM const & ) const = default;
#else
bool operator==( DataGraphPipelineBuiltinModelCreateInfoQCOM 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 ) && ( pOperation == rhs.pOperation );
# endif
}
bool operator!=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM;
const void * pNext = {};
const PhysicalDeviceDataGraphOperationSupportARM * pOperation = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkDataGraphPipelineBuiltinModelCreateInfoQCOM>
{
using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM;
};
#endif
template <>
struct CppType<StructureType, StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM>
{
using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM;
};
// wrapper struct for struct VkDataGraphPipelineCompilerControlCreateInfoARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineCompilerControlCreateInfoARM.html
struct DataGraphPipelineCompilerControlCreateInfoARM
@ -39031,61 +39294,19 @@ namespace VULKAN_HPP_NAMESPACE
{
}
# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
DeviceFaultInfoEXT( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceFaultInfoEXT( *reinterpret_cast<DeviceFaultInfoEXT const *>( &rhs ) ) {}
DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# else
DeviceFaultInfoEXT( DeviceFaultInfoEXT const & ) = delete;
DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT const & ) = delete;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
DeviceFaultInfoEXT( DeviceFaultInfoEXT && rhs ) VULKAN_HPP_NOEXCEPT
: pNext{ rhs.pNext }
, pAddressInfos{ rhs.pAddressInfos }
, pVendorInfos{ rhs.pVendorInfos }
, pVendorBinaryData{ rhs.pVendorBinaryData }
DeviceFaultInfoEXT & operator=( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
memcpy( description, rhs.description, VK_MAX_DESCRIPTION_SIZE );
rhs.pNext = nullptr;
memset( rhs.description, 0, VK_MAX_DESCRIPTION_SIZE );
rhs.pAddressInfos = nullptr;
rhs.pVendorInfos = nullptr;
rhs.pVendorBinaryData = nullptr;
}
DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT && rhs ) VULKAN_HPP_NOEXCEPT
{
free( pAddressInfos );
free( pVendorInfos );
free( pVendorBinaryData );
pNext = rhs.pNext;
memcpy( description, rhs.description, VK_MAX_DESCRIPTION_SIZE );
pAddressInfos = rhs.pAddressInfos;
pVendorInfos = rhs.pVendorInfos;
pVendorBinaryData = rhs.pVendorBinaryData;
rhs.pNext = nullptr;
memset( rhs.description, 0, VK_MAX_DESCRIPTION_SIZE );
rhs.pAddressInfos = nullptr;
rhs.pVendorInfos = nullptr;
rhs.pVendorBinaryData = nullptr;
*this = *reinterpret_cast<DeviceFaultInfoEXT const *>( &rhs );
return *this;
}
~DeviceFaultInfoEXT() VULKAN_HPP_NOEXCEPT
{
free( pAddressInfos );
free( pVendorInfos );
free( pVendorBinaryData );
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
operator VkDeviceFaultInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceFaultInfoEXT *>( this );
@ -82469,155 +82690,117 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceDataGraphFeaturesARM;
};
// wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html
struct PhysicalDeviceDataGraphOperationSupportARM
// wrapper struct for struct VkPhysicalDeviceDataGraphModelFeaturesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphModelFeaturesQCOM.html
struct PhysicalDeviceDataGraphModelFeaturesQCOM
{
using NativeType = VkPhysicalDeviceDataGraphOperationSupportARM;
using NativeType = VkPhysicalDeviceDataGraphModelFeaturesQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM(
PhysicalDeviceDataGraphOperationTypeARM operationType_ = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet,
std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const & name_ = {},
uint32_t version_ = {} ) VULKAN_HPP_NOEXCEPT
: operationType{ operationType_ }
, name{ name_ }
, version{ version_ }
VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( Bool32 dataGraphModel_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, dataGraphModel{ dataGraphModel_ }
{
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceDataGraphOperationSupportARM( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceDataGraphOperationSupportARM( *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs ) )
PhysicalDeviceDataGraphModelFeaturesQCOM( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceDataGraphModelFeaturesQCOM( *reinterpret_cast<PhysicalDeviceDataGraphModelFeaturesQCOM const *>( &rhs ) )
{
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationTypeARM operationType_, std::string const & name_, uint32_t version_ = {} )
: operationType( operationType_ ), version( version_ )
{
VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
# if defined( _WIN32 )
strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
# else
strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
# endif
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
PhysicalDeviceDataGraphOperationSupportARM & operator=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceDataGraphOperationSupportARM & operator=( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs );
*this = *reinterpret_cast<PhysicalDeviceDataGraphModelFeaturesQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
operationType = operationType_;
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
setName( std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setDataGraphModel( Bool32 dataGraphModel_ ) VULKAN_HPP_NOEXCEPT
{
name = name_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
PhysicalDeviceDataGraphOperationSupportARM & setName( std::string const & name_ ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
# if defined( _WIN32 )
strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
# else
strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
# endif
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setVersion( uint32_t version_ ) VULKAN_HPP_NOEXCEPT
{
version = version_;
dataGraphModel = dataGraphModel_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceDataGraphOperationSupportARM const &() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
return *reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
}
operator VkPhysicalDeviceDataGraphOperationSupportARM &() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceDataGraphModelFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
return *reinterpret_cast<VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
}
operator VkPhysicalDeviceDataGraphOperationSupportARM const *() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
return reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
}
operator VkPhysicalDeviceDataGraphOperationSupportARM *() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceDataGraphModelFeaturesQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
return reinterpret_cast<VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<PhysicalDeviceDataGraphOperationTypeARM const &,
ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const &,
uint32_t const &>
reflect() const VULKAN_HPP_NOEXCEPT
std::tuple<StructureType const &, const void * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( operationType, name, version );
return std::tie( sType, pNext, dataGraphModel );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
std::strong_ordering operator<=>( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
auto operator<=>( PhysicalDeviceDataGraphModelFeaturesQCOM const & ) const = default;
#else
bool operator==( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
if ( auto cmp = operationType <=> rhs.operationType; cmp != 0 )
return cmp;
if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 )
return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
if ( auto cmp = version <=> rhs.version; cmp != 0 )
return cmp;
return std::strong_ordering::equivalent;
}
#endif
bool operator==( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( operationType == rhs.operationType ) && ( strcmp( name, rhs.name ) == 0 ) && ( version == rhs.version );
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraphModel == rhs.dataGraphModel );
# endif
}
bool operator!=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
PhysicalDeviceDataGraphOperationTypeARM operationType = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet;
ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name = {};
uint32_t version = {};
StructureType sType = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM;
const void * pNext = {};
Bool32 dataGraphModel = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDeviceDataGraphOperationSupportARM>
struct CppType<VkPhysicalDeviceDataGraphModelFeaturesQCOM>
{
using Type = PhysicalDeviceDataGraphOperationSupportARM;
using Type = PhysicalDeviceDataGraphModelFeaturesQCOM;
};
#endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM>
{
using Type = PhysicalDeviceDataGraphModelFeaturesQCOM;
};
// wrapper struct for struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html
struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
@ -90373,6 +90556,21 @@ namespace VULKAN_HPP_NAMESPACE
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE &
setFragmentDensityMapLayered( Bool32 fragmentDensityMapLayered_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityMapLayered = fragmentDensityMapLayered_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *>( this );
@ -126697,6 +126895,143 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PipelineCacheCreateInfo;
};
// wrapper struct for struct VkPipelineCacheHeaderVersionDataGraphQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionDataGraphQCOM.html
struct PipelineCacheHeaderVersionDataGraphQCOM
{
using NativeType = VkPipelineCacheHeaderVersionDataGraphQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM(
uint32_t headerSize_ = {},
PipelineCacheHeaderVersion headerVersion_ = PipelineCacheHeaderVersion::eOne,
DataGraphModelCacheTypeQCOM cacheType_ = DataGraphModelCacheTypeQCOM::eGenericBinary,
uint32_t cacheVersion_ = {},
std::array<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> const & toolchainVersion_ = {} ) VULKAN_HPP_NOEXCEPT
: headerSize{ headerSize_ }
, headerVersion{ headerVersion_ }
, cacheType{ cacheType_ }
, cacheVersion{ cacheVersion_ }
, toolchainVersion{ toolchainVersion_ }
{
}
VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PipelineCacheHeaderVersionDataGraphQCOM( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PipelineCacheHeaderVersionDataGraphQCOM( *reinterpret_cast<PipelineCacheHeaderVersionDataGraphQCOM const *>( &rhs ) )
{
}
PipelineCacheHeaderVersionDataGraphQCOM & operator=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PipelineCacheHeaderVersionDataGraphQCOM & operator=( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PipelineCacheHeaderVersionDataGraphQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderSize( uint32_t headerSize_ ) VULKAN_HPP_NOEXCEPT
{
headerSize = headerSize_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) VULKAN_HPP_NOEXCEPT
{
headerVersion = headerVersion_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheType( DataGraphModelCacheTypeQCOM cacheType_ ) VULKAN_HPP_NOEXCEPT
{
cacheType = cacheType_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheVersion( uint32_t cacheVersion_ ) VULKAN_HPP_NOEXCEPT
{
cacheVersion = cacheVersion_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM &
setToolchainVersion( std::array<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> toolchainVersion_ ) VULKAN_HPP_NOEXCEPT
{
toolchainVersion = toolchainVersion_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPipelineCacheHeaderVersionDataGraphQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
}
operator VkPipelineCacheHeaderVersionDataGraphQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
}
operator VkPipelineCacheHeaderVersionDataGraphQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
}
operator VkPipelineCacheHeaderVersionDataGraphQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<uint32_t const &,
PipelineCacheHeaderVersion const &,
DataGraphModelCacheTypeQCOM const &,
uint32_t const &,
ArrayWrapper1D<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> const &>
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( headerSize, headerVersion, cacheType, cacheVersion, toolchainVersion );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCacheHeaderVersionDataGraphQCOM const & ) const = default;
#else
bool operator==( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && ( cacheType == rhs.cacheType ) &&
( cacheVersion == rhs.cacheVersion ) && ( toolchainVersion == rhs.toolchainVersion );
# endif
}
bool operator!=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
uint32_t headerSize = {};
PipelineCacheHeaderVersion headerVersion = PipelineCacheHeaderVersion::eOne;
DataGraphModelCacheTypeQCOM cacheType = DataGraphModelCacheTypeQCOM::eGenericBinary;
uint32_t cacheVersion = {};
ArrayWrapper1D<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> toolchainVersion = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPipelineCacheHeaderVersionDataGraphQCOM>
{
using Type = PipelineCacheHeaderVersionDataGraphQCOM;
};
#endif
// wrapper struct for struct VkPipelineCacheHeaderVersionOne, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionOne.html
struct PipelineCacheHeaderVersionOne

26
include/vulkan/vulkan_to_string.hpp
View file

@ -5564,6 +5564,8 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT : return "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT";
case StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR : return "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR";
case StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT : return "PhysicalDeviceShader64BitIndexingFeaturesEXT";
case StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM : return "PhysicalDeviceDataGraphModelFeaturesQCOM";
case StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM : return "DataGraphPipelineBuiltinModelCreateInfoQCOM";
case StructureType::ePhysicalDeviceMaintenance10FeaturesKHR : return "PhysicalDeviceMaintenance10FeaturesKHR";
case StructureType::ePhysicalDeviceMaintenance10PropertiesKHR : return "PhysicalDeviceMaintenance10PropertiesKHR";
case StructureType::eRenderingAttachmentFlagsInfoKHR : return "RenderingAttachmentFlagsInfoKHR";
@ -6589,8 +6591,9 @@ namespace VULKAN_HPP_NAMESPACE
{
switch ( value )
{
case PipelineCacheHeaderVersion::eOne: return "One";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
case PipelineCacheHeaderVersion::eOne : return "One";
case PipelineCacheHeaderVersion::eDataGraphQCOM: return "DataGraphQCOM";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -10366,8 +10369,10 @@ namespace VULKAN_HPP_NAMESPACE
{
switch ( value )
{
case PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault: return "Default";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
case PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault : return "Default";
case PhysicalDeviceDataGraphProcessingEngineTypeARM::eNeuralQCOM : return "NeuralQCOM";
case PhysicalDeviceDataGraphProcessingEngineTypeARM::eComputeQCOM: return "ComputeQCOM";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -10376,6 +10381,8 @@ namespace VULKAN_HPP_NAMESPACE
switch ( value )
{
case PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet: return "SpirvExtendedInstructionSet";
case PhysicalDeviceDataGraphOperationTypeARM::eNeuralModelQCOM : return "NeuralModelQCOM";
case PhysicalDeviceDataGraphOperationTypeARM::eBuiltinModelQCOM : return "BuiltinModelQCOM";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -10802,6 +10809,17 @@ namespace VULKAN_HPP_NAMESPACE
return "(void)";
}
//=== VK_QCOM_data_graph_model ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphModelCacheTypeQCOM value )
{
switch ( value )
{
case DataGraphModelCacheTypeQCOM::eGenericBinary: return "GenericBinary";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
//=== VK_KHR_maintenance10 ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderingAttachmentFlagBitsKHR value )

559
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

92
registry/vk.xml
View file

@ -183,7 +183,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,vulkanbase" category="define">// Version of this file
#define <name>VK_HEADER_VERSION</name> 331</type>
#define <name>VK_HEADER_VERSION</name> 332</type>
<type api="vulkan,vulkanbase" 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, 4, VK_HEADER_VERSION)</type>
<type api="vulkansc" category="define">// Version of this file
@ -897,6 +897,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkDataGraphPipelineDispatchFlagBitsARM" category="enum"/>
<type name="VkPhysicalDeviceDataGraphProcessingEngineTypeARM" category="enum"/>
<type name="VkPhysicalDeviceDataGraphOperationTypeARM" category="enum"/>
<type name="VkDataGraphModelCacheTypeQCOM" category="enum"/>
<type name="VkVideoEncodeRgbModelConversionFlagBitsVALVE" category="enum"/>
<type name="VkVideoEncodeRgbRangeCompressionFlagBitsVALVE" category="enum"/>
<type name="VkVideoEncodeRgbChromaOffsetFlagBitsVALVE" category="enum"/>
@ -1813,6 +1814,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>uint32_t</type> <name>pipelineIndexStride</name></member>
<member><type>uint64_t</type> <name>pipelineIndexOffset</name></member>
</type>
<type category="struct" name="VkPipelineCacheHeaderVersionDataGraphQCOM">
<comment>The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout.</comment>
<member><type>uint32_t</type> <name>headerSize</name></member>
<member><type>VkPipelineCacheHeaderVersion</type> <name>headerVersion</name></member>
<member><type>VkDataGraphModelCacheTypeQCOM</type> <name>cacheType</name></member>
<member><type>uint32_t</type> <name>cacheVersion</name></member>
<member><type>uint32_t</type> <name>toolchainVersion</name>[<enum>VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM</enum>]</member>
</type>
<type category="struct" name="VkPushConstantRange">
<member><type>VkShaderStageFlags</type> <name>stageFlags</name><comment>Which stages use the range</comment></member>
<member><type>uint32_t</type> <name>offset</name><comment>Start of the range, in bytes</comment></member>
@ -10545,7 +10554,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxFragmentDensityMapLayers</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE" returnedonly="true" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>fragmentDensityMapLayered</name></member>
@ -10927,6 +10936,16 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>pipelineCacheIncrementalMode</name></member>
</type>
<type category="struct" name="VkDataGraphPipelineBuiltinModelCreateInfoQCOM" structextends="VkDataGraphPipelineCreateInfoARM">
<member values="VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member>const <type>VkPhysicalDeviceDataGraphOperationSupportARM</type>* <name>pOperation</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceDataGraphModelFeaturesQCOM" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member featurelink="dataGraphModelQCOM"><type>VkBool32</type> <name>dataGraphModel</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceShaderUntypedPointersFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
@ -11089,6 +11108,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum type="uint32_t" value="128" name="VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX"/>
<enum type="uint32_t" value="128" name="VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX"/>
<enum type="uint32_t" value="128" name="VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM"/>
<enum type="uint32_t" value="3" name="VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM"/>
</enums>
<comment>
@ -13332,6 +13352,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enums name="VkPhysicalDeviceDataGraphOperationTypeARM" type="enum">
<enum value="0" name="VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM"/>
</enums>
<enums name="VkDataGraphModelCacheTypeQCOM" type="enum">
<enum value="0" name="VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM"/>
</enums>
<enums name="VkVideoEncodeRgbModelConversionFlagBitsVALVE" type="bitmask">
<enum bitpos="0" name="VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE"/>
<enum bitpos="1" name="VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE"/>
@ -17790,7 +17813,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command conditionalrendering="false" queues="VK_QUEUE_TRANSFER_BIT,VK_QUEUE_GRAPHICS_BIT,VK_QUEUE_COMPUTE_BIT" renderpass="outside" cmdbufferlevel="primary,secondary" tasks="action">
<proto><type>void</type> <name>vkCmdCopyTensorARM</name></proto>
<param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
<param> const <type>VkCopyTensorInfoARM</type>* <name>pCopyTensorInfo</name></param>
<param>const <type>VkCopyTensorInfoARM</type>* <name>pCopyTensorInfo</name></param>
</command>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_UNKNOWN,VK_ERROR_VALIDATION_FAILED">
<proto><type>VkResult</type> <name>vkGetTensorOpaqueCaptureDescriptorDataARM</name></proto>
@ -24465,7 +24488,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_QCOM_extension_307&quot;" name="VK_QCOM_EXTENSION_307_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_NV_cuda_kernel_launch" number="308" type="device" author="NV" contact="Tristan Lorach @tlorach" supported="vulkan" provisional="true" platform="provisional">
<extension name="VK_NV_cuda_kernel_launch" number="308" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="NV" contact="Tristan Lorach @tlorach" supported="vulkan" provisional="true" platform="provisional">
<require>
<enum value="2" name="VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION"/>
<enum value="&quot;VK_NV_cuda_kernel_launch&quot;" name="VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME"/>
@ -25567,7 +25590,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<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">
<extension name="VK_EXT_frame_boundary" number="376" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="EXT" contact="James Fitzpatrick @jamesfitzpatrick" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_FRAME_BOUNDARY_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_frame_boundary&quot;" name="VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME"/>
@ -26041,7 +26064,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkPhysicalDeviceShaderCorePropertiesARM"/>
</require>
</extension>
<extension name="VK_KHR_shader_subgroup_rotate" number="417" author="KHR" contact="Kevin Petit @kpet" type="device" supported="vulkan" promotedto="VK_VERSION_1_4" ratified="vulkan">
<extension name="VK_KHR_shader_subgroup_rotate" number="417" author="KHR" contact="Kevin Petit @kpet" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" supported="vulkan" promotedto="VK_VERSION_1_4" ratified="vulkan">
<require>
<enum value="2" name="VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_shader_subgroup_rotate&quot;" name="VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME"/>
@ -26406,7 +26429,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
</extension>
<extension name="VK_OHOS_external_memory" number="453" type="device" author="HUAWEI" depends="((VK_KHR_sampler_ycbcr_conversion+VK_KHR_external_memory+VK_KHR_dedicated_allocation),VK_VERSION_1_1)+VK_EXT_queue_family_foreign" platform="ohos" contact="Weilan Chen @wchen-h" supported="vulkan" nofeatures="true">
<require>
<enum value="2" name="VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION"/>
<enum value="1" name="VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION"/>
<enum value="&quot;VK_OHOS_external_memory&quot;" name="VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS"/>
@ -27012,7 +27035,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_AMD_extension_476&quot;" name="VK_AMD_EXTENSION_476_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_AMD_anti_lag" number="477" type="device" author="AMD" contact="Stu Smith" supported="vulkan">
<extension name="VK_AMD_anti_lag" number="477" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="AMD" contact="Stu Smith" supported="vulkan">
<require>
<enum value="1" name="VK_AMD_ANTI_LAG_SPEC_VERSION"/>
<enum value="&quot;VK_AMD_anti_lag&quot;" name="VK_AMD_ANTI_LAG_EXTENSION_NAME"/>
@ -27386,7 +27409,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="rayTracingInvocationReorder" struct="VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV"/>
</require>
</extension>
<extension name="VK_NV_cooperative_vector" number="492" author="NV" type="device" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
<extension name="VK_NV_cooperative_vector" number="492" author="NV" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
<require>
<enum value="4" name="VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION"/>
<enum value="&quot;VK_NV_cooperative_vector&quot;" name="VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME"/>
@ -27413,7 +27436,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="cooperativeVector" struct="VkPhysicalDeviceCooperativeVectorFeaturesNV"/>
</require>
</extension>
<extension name="VK_NV_extended_sparse_address_space" number="493" type="device" author="NV" contact="Russell Chou @russellcnv" supported="vulkan">
<extension name="VK_NV_extended_sparse_address_space" number="493" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Russell Chou @russellcnv" supported="vulkan">
<require>
<enum value="1" name="VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extended_sparse_address_space&quot;" name="VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME"/>
@ -27667,7 +27690,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_MESA_extension_510&quot;" name="VK_MESA_EXTENSION_510_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_QCOM_multiview_per_view_render_areas" number="511" type="device" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
<extension name="VK_QCOM_multiview_per_view_render_areas" number="511" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
<require>
<enum value="1" name="VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_multiview_per_view_render_areas&quot;" name="VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME"/>
@ -27825,7 +27848,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="selectableCubicWeights" struct="VkPhysicalDeviceCubicWeightsFeaturesQCOM"/>
</require>
</extension>
<extension name="VK_QCOM_ycbcr_degamma" number="521" type="device" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
<extension name="VK_QCOM_ycbcr_degamma" number="521" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
<require>
<enum value="1" name="VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_ycbcr_degamma&quot;" name="VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME"/>
@ -27891,7 +27914,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum extends="VkAttachmentStoreOp" name="VK_ATTACHMENT_STORE_OP_NONE_KHR" alias="VK_ATTACHMENT_STORE_OP_NONE"/>
</require>
</extension>
<extension name="VK_KHR_unified_image_layouts" number="528" author="KHR" type="device" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan">
<extension name="VK_KHR_unified_image_layouts" number="528" author="KHR" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_unified_image_layouts&quot;" name="VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME"/>
@ -28274,7 +28297,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_IMG_extension_555&quot;" name="VK_IMG_EXTENSION_555_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_NV_raw_access_chains" number="556" type="device" author="NV" contact="Rodrigo Locatti @rlocatti" supported="vulkan">
<extension name="VK_NV_raw_access_chains" number="556" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Rodrigo Locatti @rlocatti" supported="vulkan">
<require>
<enum value="1" name="VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION"/>
<enum value="&quot;VK_NV_raw_access_chains&quot;" name="VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME"/>
@ -28308,7 +28331,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_KHR_extension_558&quot;" name="VK_KHR_EXTENSION_558_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_KHR_shader_relaxed_extended_instruction" number="559" type="device" author="KHR" contact="Nathan Gauër @Keenuts" supported="vulkan" ratified="vulkan">
<extension name="VK_KHR_shader_relaxed_extended_instruction" number="559" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="KHR" contact="Nathan Gauër @Keenuts" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_shader_relaxed_extended_instruction&quot;" name="VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME"/>
@ -28317,7 +28340,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="shaderRelaxedExtendedInstruction" struct="VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"/>
</require>
</extension>
<extension name="VK_NV_command_buffer_inheritance" number="560" type="device" author="NV" contact="Lujin Wang @lujinwangnv" supported="vulkan">
<extension name="VK_NV_command_buffer_inheritance" number="560" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="NV" contact="Lujin Wang @lujinwangnv" supported="vulkan">
<require>
<enum value="1" name="VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION"/>
<enum value="&quot;VK_NV_command_buffer_inheritance&quot;" name="VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME"/>
@ -28358,7 +28381,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="maintenance7" struct="VkPhysicalDeviceMaintenance7FeaturesKHR"/>
</require>
</extension>
<extension name="VK_NV_shader_atomic_float16_vector" number="564" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
<extension name="VK_NV_shader_atomic_float16_vector" number="564" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
<require>
<enum value="1" name="VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION"/>
<enum value="&quot;VK_NV_shader_atomic_float16_vector&quot;" name="VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME"/>
@ -28367,7 +28390,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="shaderFloat16VectorAtomics" struct="VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"/>
</require>
</extension>
<extension name="VK_EXT_shader_replicated_composites" number="565" type="device" author="EXT" contact="Kevin Petit @kpet" supported="vulkan" ratified="vulkan">
<extension name="VK_EXT_shader_replicated_composites" number="565" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="EXT" contact="Kevin Petit @kpet" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_shader_replicated_composites&quot;" name="VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME"/>
@ -28388,7 +28411,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_ARM_extension_567&quot;" name="VK_ARM_EXTENSION_567_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_shader_float8" number="568" author="EXT" contact="Kevin Petit @kpet" type="device" supported="vulkan" ratified="vulkan">
<extension name="VK_EXT_shader_float8" number="568" author="EXT" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Kevin Petit @kpet" type="device" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_SHADER_FLOAT8_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_shader_float8&quot;" name="VK_EXT_SHADER_FLOAT8_EXTENSION_NAME"/>
@ -28401,7 +28424,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum offset="3" extnumber="492" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT"/>
</require>
</extension>
<extension name="VK_NV_ray_tracing_validation" number="569" type="device" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
<extension name="VK_NV_ray_tracing_validation" number="569" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
<require>
<enum value="1" name="VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION"/>
<enum value="&quot;VK_NV_ray_tracing_validation&quot;" name="VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME"/>
@ -28624,7 +28647,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="9" extends="VkShaderCreateFlagBitsEXT" name="VK_SHADER_CREATE_RESERVED_9_BIT_EXT"/>
</require>
</extension>
<extension name="VK_KHR_shader_fma" number="580" type="device" author="KHR" contact="Graeme Leese @gnl21" supported="vulkan" ratified="vulkan">
<extension name="VK_KHR_shader_fma" number="580" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" type="device" author="KHR" contact="Graeme Leese @gnl21" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_KHR_SHADER_FMA_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_shader_fma&quot;" name="VK_KHR_SHADER_FMA_EXTENSION_NAME"/>
@ -28925,7 +28948,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="vertexAttributeRobustness" struct="VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"/>
</require>
</extension>
<extension name="VK_ARM_format_pack" number="610" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan">
<extension name="VK_ARM_format_pack" number="610" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan">
<require>
<enum value="1" name="VK_ARM_FORMAT_PACK_SPEC_VERSION"/>
<enum value="&quot;VK_ARM_format_pack&quot;" name="VK_ARM_FORMAT_PACK_EXTENSION_NAME"/>
@ -28981,7 +29004,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="robustBufferAccess2,robustImageAccess2,nullDescriptor" struct="VkPhysicalDeviceRobustness2FeaturesKHR"/>
</require>
</extension>
<extension name="VK_NV_present_metering" number="614" type="device" author="NV" contact="Charles Hansen @chansen" supported="vulkan" provisional="true" platform="provisional">
<extension name="VK_NV_present_metering" number="614" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Charles Hansen @chansen" supported="vulkan" provisional="true" platform="provisional">
<require>
<enum value="1" name="VK_NV_PRESENT_METERING_SPEC_VERSION"/>
<enum value="&quot;VK_NV_present_metering&quot;" name="VK_NV_PRESENT_METERING_EXTENSION_NAME"/>
@ -29113,10 +29136,23 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="5" extends="VkResolveModeFlagBits" name="VK_RESOLVE_MODE_RESERVED_5_BIT_EXT"/>
</require>
</extension>
<extension name="VK_EXT_extension_630" number="630" author="EXT" contact="Matthew Netsch @mnetsch" supported="disabled">
<extension name="VK_QCOM_data_graph_model" number="630" author="QCOM" type="device" depends="VK_ARM_data_graph" contact="Matthew Netsch @mnetsch" supported="vulkan">
<require>
<enum value="0" name="VK_EXT_EXTENSION_630_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_630&quot;" name="VK_EXT_EXTENSION_630_EXTENSION_NAME"/>
<enum value="1" name="VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_data_graph_model&quot;" name="VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM"/>
<enum offset="0" extends="VkPhysicalDeviceDataGraphProcessingEngineTypeARM" name="VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM"/>
<enum offset="1" extends="VkPhysicalDeviceDataGraphProcessingEngineTypeARM" name="VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM"/>
<enum offset="0" extends="VkPhysicalDeviceDataGraphOperationTypeARM" name="VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM"/>
<enum offset="1" extends="VkPhysicalDeviceDataGraphOperationTypeARM" name="VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM"/>
<enum offset="0" extends="VkPipelineCacheHeaderVersion" name="VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM"/>
<enum name="VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM"/>
<type name="VkDataGraphModelCacheTypeQCOM"/>
<type name="VkPipelineCacheHeaderVersionDataGraphQCOM"/>
<type name="VkDataGraphPipelineBuiltinModelCreateInfoQCOM"/>
<type name="VkPhysicalDeviceDataGraphModelFeaturesQCOM"/>
<feature name="dataGraphModel" struct="VkPhysicalDeviceDataGraphModelFeaturesQCOM"/>
</require>
</extension>
<extension name="VK_KHR_maintenance10" number="631" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="KHR" contact="Mike Blumenkrantz @zmike" supported="vulkan" ratified="vulkan">
@ -29200,7 +29236,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_637&quot;" name="VK_EXT_EXTENSION_637_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_SEC_pipeline_cache_incremental_mode" number="638" author="SEC" contact="Chris Hambacher @chambacher" type="device" supported="vulkan">
<extension name="VK_SEC_pipeline_cache_incremental_mode" number="638" author="SEC" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Chris Hambacher @chambacher" type="device" supported="vulkan">
<require>
<enum value="1" name="VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION"/>
<enum value="&quot;VK_SEC_pipeline_cache_incremental_mode&quot;" name="VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME"/>
@ -29234,7 +29270,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_642&quot;" name="VK_EXT_EXTENSION_642_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_shader_uniform_buffer_unsized_array" number="643" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan" ratified="vulkan">
<extension name="VK_EXT_shader_uniform_buffer_unsized_array" number="643" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_shader_uniform_buffer_unsized_array&quot;" name="VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME"/>