organicmaps/Vulkan-Headers
13
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Headers.git synced 2025-04-10 14:51:30 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions

Update for Vulkan-Docs 1.4.306

Browse source
This commit is contained in:
Jon Leech 2025-01-24 05:49:59 -08:00
parent a03d2f6d57
commit 8694fed69b
15 changed files with 1956 additions and 342 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
include/vulkan/vulkan.cppm
View file

@ -2654,6 +2654,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTDepthClampControlExtensionName;
using VULKAN_HPP_NAMESPACE::EXTDepthClampControlSpecVersion;
//=== VK_KHR_video_maintenance2 ===
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2SpecVersion;
//=== VK_HUAWEI_hdr_vivid ===
using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividExtensionName;
using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividSpecVersion;
@ -2666,6 +2670,12 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapExtensionName;
using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapSpecVersion;
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalExtensionName;
using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalSpecVersion;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_depth_clamp_zero_one ===
using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneExtensionName;
using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneSpecVersion;
@ -4681,6 +4691,12 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT;
//=== VK_KHR_video_maintenance2 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR;
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR;
//=== VK_HUAWEI_hdr_vivid ===
using VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI;
@ -4693,6 +4709,13 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_ARM_pipeline_opacity_micromap ===
using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM;
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
using VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT;
using VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT;
using VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_depth_clamp_zero_one ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR;
@ -8253,6 +8276,16 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::DepthClampRangeEXT>;
//=== VK_KHR_video_maintenance2 ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>;
//=== VK_HUAWEI_hdr_vivid ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI>;
@ -8271,6 +8304,16 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>;
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_depth_clamp_zero_one ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR>;

110
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 == 305, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 306, "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)
@ -6150,6 +6150,24 @@ namespace VULKAN_HPP_NAMESPACE
{
return ::vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( physicalDevice, pPropertyCount, pProperties );
}
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
VkResult
vkGetMemoryMetalHandleEXT( VkDevice device, const VkMemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo, void ** pHandle ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryMetalHandleEXT( device, pGetMetalHandleInfo, pHandle );
}
VkResult vkGetMemoryMetalHandlePropertiesEXT( VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
const void * pHandle,
VkMemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryMetalHandlePropertiesEXT( device, handleType, pHandle, pMemoryMetalHandleProperties );
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/
};
inline DispatchLoaderStatic & getDispatchLoaderStatic()
@ -8849,6 +8867,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_KHR_video_maintenance2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2ExtensionName = VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2SpecVersion = VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION;
//=== VK_HUAWEI_hdr_vivid ===
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividExtensionName = VK_HUAWEI_HDR_VIVID_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividSpecVersion = VK_HUAWEI_HDR_VIVID_SPEC_VERSION;
@ -8861,6 +8883,12 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapExtensionName = VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapSpecVersion = VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryMetalExtensionName = VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryMetalSpecVersion = VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_depth_clamp_zero_one ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneExtensionName = VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneSpecVersion = VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION;
@ -17551,6 +17579,52 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_video_maintenance2 ===
template <>
struct StructExtends<PhysicalDeviceVideoMaintenance2FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVideoMaintenance2FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH264InlineSessionParametersInfoKHR, VideoDecodeInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH265InlineSessionParametersInfoKHR, VideoDecodeInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeAV1InlineSessionParametersInfoKHR, VideoDecodeInfoKHR>
{
enum
{
value = true
};
};
//=== VK_HUAWEI_hdr_vivid ===
template <>
struct StructExtends<PhysicalDeviceHdrVividFeaturesHUAWEI, PhysicalDeviceFeatures2>
@ -17626,6 +17700,18 @@ namespace VULKAN_HPP_NAMESPACE
};
};
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
template <>
struct StructExtends<ImportMemoryMetalHandleInfoEXT, MemoryAllocateInfo>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_depth_clamp_zero_one ===
template <>
struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesKHR, PhysicalDeviceFeatures2>
@ -18973,6 +19059,15 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_cooperative_matrix2 ===
PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0;
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT = 0;
PFN_vkGetMemoryMetalHandlePropertiesEXT vkGetMemoryMetalHandlePropertiesEXT = 0;
#else
PFN_dummy vkGetMemoryMetalHandleEXT_placeholder = 0;
PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
public:
DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
@ -20489,6 +20584,13 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_cooperative_matrix2 ===
vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) );
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandleEXT" ) );
vkGetMemoryMetalHandlePropertiesEXT =
PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandlePropertiesEXT" ) );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
}
void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
@ -21633,6 +21735,12 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetPipelineEXT" ) );
vkUpdateIndirectExecutionSetShaderEXT =
PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) );
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
}
template <typename DynamicLoader>

46
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 305
#define VK_HEADER_VERSION 306
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1191,12 +1191,19 @@ 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_VIDEO_MAINTENANCE_2_FEATURES_KHR = 1000586000,
VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586001,
VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586002,
VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586003,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI = 1000590000,
VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI = 1000590001,
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_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM = 1000596000,
VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT = 1000602000,
VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT = 1000602001,
VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
@ -5177,6 +5184,9 @@ typedef enum VkExternalMemoryHandleTypeFlagBits {
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX = 0x00004000,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT = 0x00010000,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT = 0x00020000,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT = 0x00040000,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
@ -8948,6 +8958,7 @@ typedef enum VkVideoSessionCreateFlagBitsKHR {
VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR = 0x00000004,
VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000008,
VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x00000010,
VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR = 0x00000020,
VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoSessionCreateFlagBitsKHR;
typedef VkFlags VkVideoSessionCreateFlagsKHR;
@ -12814,6 +12825,39 @@ typedef struct VkMemoryBarrierAccessFlags3KHR {
// VK_KHR_video_maintenance2 is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_video_maintenance2 1
#define VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION 1
#define VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_video_maintenance2"
typedef struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 videoMaintenance2;
} VkPhysicalDeviceVideoMaintenance2FeaturesKHR;
typedef struct VkVideoDecodeH264InlineSessionParametersInfoKHR {
VkStructureType sType;
const void* pNext;
const StdVideoH264SequenceParameterSet* pStdSPS;
const StdVideoH264PictureParameterSet* pStdPPS;
} VkVideoDecodeH264InlineSessionParametersInfoKHR;
typedef struct VkVideoDecodeH265InlineSessionParametersInfoKHR {
VkStructureType sType;
const void* pNext;
const StdVideoH265VideoParameterSet* pStdVPS;
const StdVideoH265SequenceParameterSet* pStdSPS;
const StdVideoH265PictureParameterSet* pStdPPS;
} VkVideoDecodeH265InlineSessionParametersInfoKHR;
typedef struct VkVideoDecodeAV1InlineSessionParametersInfoKHR {
VkStructureType sType;
const void* pNext;
const StdVideoAV1SequenceHeader* pStdSequenceHeader;
} VkVideoDecodeAV1InlineSessionParametersInfoKHR;
// VK_KHR_depth_clamp_zero_one is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_depth_clamp_zero_one 1
#define VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1

30
include/vulkan/vulkan_enums.hpp
View file

@ -1544,15 +1544,24 @@ namespace VULKAN_HPP_NAMESPACE
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,
ePhysicalDeviceVideoMaintenance2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR,
eVideoDecodeH264InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR,
eVideoDecodeH265InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR,
eVideoDecodeAv1InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR,
ePhysicalDeviceHdrVividFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI,
eHdrVividDynamicMetadataHUAWEI = VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI,
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,
ePhysicalDevicePipelineOpacityMicromapFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM,
ePhysicalDeviceDepthClampZeroOneFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT,
ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT
#if defined( VK_USE_PLATFORM_METAL_EXT )
eImportMemoryMetalHandleInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT,
eMemoryMetalHandlePropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT,
eMemoryGetMetalHandleInfoEXT = VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT,
#endif /*VK_USE_PLATFORM_METAL_EXT*/
ePhysicalDeviceDepthClampZeroOneFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT,
ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT
};
enum class PipelineCacheHeaderVersion
@ -3961,8 +3970,13 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_FUCHSIA*/
eRdmaAddressNV = VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV,
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
eScreenBufferQNX = VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX
eScreenBufferQNX = VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX,
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
eMtlbufferEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT,
eMtltextureEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT,
eMtlheapEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT
#endif /*VK_USE_PLATFORM_METAL_EXT*/
};
using ExternalMemoryHandleTypeFlagBitsKHR = ExternalMemoryHandleTypeFlagBits;
@ -3988,6 +4002,9 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
| ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
| ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT | ExternalMemoryHandleTypeFlagBits::eMtltextureEXT | ExternalMemoryHandleTypeFlagBits::eMtlheapEXT
#endif /*VK_USE_PLATFORM_METAL_EXT*/
;
};
@ -5218,7 +5235,8 @@ namespace VULKAN_HPP_NAMESPACE
eAllowEncodeParameterOptimizations = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR,
eInlineQueries = VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR,
eAllowEncodeQuantizationDeltaMap = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR,
eAllowEncodeEmphasisMap = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR
eAllowEncodeEmphasisMap = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR,
eInlineSessionParameters = VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR
};
using VideoSessionCreateFlagsKHR = Flags<VideoSessionCreateFlagBitsKHR>;
@ -5230,7 +5248,7 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionCreateFlagsKHR allFlags =
VideoSessionCreateFlagBitsKHR::eProtectedContent | VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations |
VideoSessionCreateFlagBitsKHR::eInlineQueries | VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap |
VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap;
VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap | VideoSessionCreateFlagBitsKHR::eInlineSessionParameters;
};
enum class VideoCodingControlFlagBitsKHR : VkVideoCodingControlFlagsKHR

28
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -457,9 +457,13 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_maintenance8",
"VK_MESA_image_alignment_control",
"VK_EXT_depth_clamp_control",
"VK_KHR_video_maintenance2",
"VK_HUAWEI_hdr_vivid",
"VK_NV_cooperative_matrix2",
"VK_ARM_pipeline_opacity_micromap",
#if defined( VK_USE_PLATFORM_METAL_EXT )
"VK_EXT_external_memory_metal",
#endif /*VK_USE_PLATFORM_METAL_EXT*/
"VK_KHR_depth_clamp_zero_one",
"VK_EXT_vertex_attribute_robustness"
};
@ -2390,6 +2394,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_video_maintenance2",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_video_decode_queue",
"VK_KHR_video_encode_queue",
} } } } },
{ "VK_HUAWEI_hdr_vivid",
{ { "VK_VERSION_1_0",
{ {
@ -2410,6 +2420,14 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_EXT_opacity_micromap",
} } } } },
#if defined( VK_USE_PLATFORM_METAL_EXT )
{ "VK_EXT_external_memory_metal",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_external_memory",
} } },
{ "VK_VERSION_1_1", { {} } } } },
#endif /*VK_USE_PLATFORM_METAL_EXT*/
{ "VK_KHR_depth_clamp_zero_one",
{ { "VK_VERSION_1_0",
{ {
@ -3285,9 +3303,13 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_NV_command_buffer_inheritance" ) || ( 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_KHR_maintenance8" ) ||
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) ||
( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" );
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) ||
( extension == "VK_ARM_pipeline_opacity_micromap" )
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

71
include/vulkan/vulkan_funcs.hpp
View file

@ -28799,5 +28799,76 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryMetalHandleEXT( const VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo,
void ** pHandle,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkGetMemoryMetalHandleEXT(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT *>( pGetMetalHandleInfo ), pHandle ) );
}
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<void *>::type
Device::getMemoryMetalHandleEXT( const VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT & getMetalHandleInfo, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetMemoryMetalHandleEXT && "Function <vkGetMemoryMetalHandleEXT> requires <VK_EXT_external_memory_metal>" );
# endif
void * handle;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
d.vkGetMemoryMetalHandleEXT( m_device, reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT *>( &getMetalHandleInfo ), &handle ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandleEXT" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) );
}
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
Device::getMemoryMetalHandlePropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
const void * pHandle,
VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkGetMemoryMetalHandlePropertiesEXT( static_cast<VkDevice>( m_device ),
static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
pHandle,
reinterpret_cast<VkMemoryMetalHandlePropertiesEXT *>( pMemoryMetalHandleProperties ) ) );
}
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename HandleType, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>::type
Device::getMemoryMetalHandlePropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
HandleType const & handle,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetMemoryMetalHandlePropertiesEXT && "Function <vkGetMemoryMetalHandlePropertiesEXT> requires <VK_EXT_external_memory_metal>" );
# endif
VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT memoryMetalHandleProperties;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
d.vkGetMemoryMetalHandlePropertiesEXT( m_device,
static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
reinterpret_cast<const void *>( &handle ),
reinterpret_cast<VkMemoryMetalHandlePropertiesEXT *>( &memoryMetalHandleProperties ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandlePropertiesEXT" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryMetalHandleProperties ) );
}
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_METAL_EXT*/
} // namespace VULKAN_HPP_NAMESPACE
#endif

41
include/vulkan/vulkan_handles.hpp
View file

@ -1967,6 +1967,12 @@ namespace VULKAN_HPP_NAMESPACE
struct PipelineViewportDepthClampControlCreateInfoEXT;
struct DepthClampRangeEXT;
//=== VK_KHR_video_maintenance2 ===
struct PhysicalDeviceVideoMaintenance2FeaturesKHR;
struct VideoDecodeH264InlineSessionParametersInfoKHR;
struct VideoDecodeH265InlineSessionParametersInfoKHR;
struct VideoDecodeAV1InlineSessionParametersInfoKHR;
//=== VK_HUAWEI_hdr_vivid ===
struct PhysicalDeviceHdrVividFeaturesHUAWEI;
struct HdrVividDynamicMetadataHUAWEI;
@ -1979,6 +1985,13 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_ARM_pipeline_opacity_micromap ===
struct PhysicalDevicePipelineOpacityMicromapFeaturesARM;
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
struct ImportMemoryMetalHandleInfoEXT;
struct MemoryMetalHandlePropertiesEXT;
struct MemoryGetMetalHandleInfoEXT;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_depth_clamp_zero_one ===
struct PhysicalDeviceDepthClampZeroOneFeaturesKHR;
using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR;
@ -15264,6 +15277,34 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getMemoryMetalHandleEXT( const VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo,
void ** pHandle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type
getMemoryMetalHandleEXT( const VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT & getMetalHandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getMemoryMetalHandlePropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
const void * pHandle,
VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename HandleType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>::type
getMemoryMetalHandlePropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
HandleType const & handle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_METAL_EXT*/
operator VkDevice() const VULKAN_HPP_NOEXCEPT
{
return m_device;

106
include/vulkan/vulkan_hash.hpp
View file

@ -6475,6 +6475,22 @@ namespace std
}
};
# if defined( VK_USE_PLATFORM_METAL_EXT )
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT const & importMemoryMetalHandleInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.handleType );
VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.handle );
return seed;
}
};
# endif /*VK_USE_PLATFORM_METAL_EXT*/
# if defined( VK_USE_PLATFORM_WIN32_KHR )
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR>
@ -7145,6 +7161,22 @@ namespace std
}
};
# if defined( VK_USE_PLATFORM_METAL_EXT )
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT const & memoryGetMetalHandleInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.memory );
VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.handleType );
return seed;
}
};
# endif /*VK_USE_PLATFORM_METAL_EXT*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
{
@ -7245,6 +7277,21 @@ namespace std
}
};
# if defined( VK_USE_PLATFORM_METAL_EXT )
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT const & memoryMetalHandlePropertiesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.memoryTypeBits );
return seed;
}
};
# endif /*VK_USE_PLATFORM_METAL_EXT*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
{
@ -12962,6 +13009,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR const & physicalDeviceVideoMaintenance2FeaturesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.videoMaintenance2 );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features>
{
@ -16561,6 +16622,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR const & videoDecodeAV1InlineSessionParametersInfoKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.pStdSequenceHeader );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR>
{
@ -16650,6 +16725,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR const & videoDecodeH264InlineSessionParametersInfoKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pStdSPS );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pStdPPS );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR>
{
@ -16738,6 +16828,22 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR const & videoDecodeH265InlineSessionParametersInfoKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdVPS );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdSPS );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdPPS );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR>
{

41
include/vulkan/vulkan_metal.h
View file

@ -188,6 +188,47 @@ VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(
VkExportMetalObjectsInfoEXT* pMetalObjectsInfo);
#endif
// VK_EXT_external_memory_metal is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_external_memory_metal 1
#define VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION 1
#define VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME "VK_EXT_external_memory_metal"
typedef struct VkImportMemoryMetalHandleInfoEXT {
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlagBits handleType;
void* handle;
} VkImportMemoryMetalHandleInfoEXT;
typedef struct VkMemoryMetalHandlePropertiesEXT {
VkStructureType sType;
void* pNext;
uint32_t memoryTypeBits;
} VkMemoryMetalHandlePropertiesEXT;
typedef struct VkMemoryGetMetalHandleInfoEXT {
VkStructureType sType;
const void* pNext;
VkDeviceMemory memory;
VkExternalMemoryHandleTypeFlagBits handleType;
} VkMemoryGetMetalHandleInfoEXT;
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle);
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(
VkDevice device,
const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo,
void** pHandle);
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(
VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
const void* pHandle,
VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
#endif
#ifdef __cplusplus
}
#endif

60
include/vulkan/vulkan_raii.hpp
View file

@ -1813,6 +1813,12 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetPipelineEXT" ) );
vkUpdateIndirectExecutionSetShaderEXT =
PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) );
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) );
# endif /*VK_USE_PLATFORM_METAL_EXT*/
}
public:
@ -2739,6 +2745,15 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkDestroyIndirectExecutionSetEXT vkDestroyIndirectExecutionSetEXT = 0;
PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0;
PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0;
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT = 0;
PFN_vkGetMemoryMetalHandlePropertiesEXT vkGetMemoryMetalHandlePropertiesEXT = 0;
# else
PFN_dummy vkGetMemoryMetalHandleEXT_placeholder = 0;
PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0;
# endif /*VK_USE_PLATFORM_METAL_EXT*/
};
} // namespace detail
@ -4872,6 +4887,16 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
VULKAN_HPP_RAII_CREATE_NOEXCEPT;
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
VULKAN_HPP_NODISCARD void * getMemoryMetalHandleEXT( const VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT & getMetalHandleInfo ) const;
template <typename HandleType>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT
getMemoryMetalHandlePropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle ) const;
# endif /*VK_USE_PLATFORM_METAL_EXT*/
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
@ -24682,6 +24707,41 @@ namespace VULKAN_HPP_NAMESPACE
return properties;
}
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void *
Device::getMemoryMetalHandleEXT( const VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT & getMetalHandleInfo ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryMetalHandleEXT && "Function <vkGetMemoryMetalHandleEXT> requires <VK_EXT_external_memory_metal>" );
void * handle;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryMetalHandleEXT(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT *>( &getMetalHandleInfo ), &handle ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandleEXT" );
return handle;
}
template <typename HandleType>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT
Device::getMemoryMetalHandlePropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryMetalHandlePropertiesEXT &&
"Function <vkGetMemoryMetalHandlePropertiesEXT> requires <VK_EXT_external_memory_metal>" );
VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT memoryMetalHandleProperties;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
getDispatcher()->vkGetMemoryMetalHandlePropertiesEXT( static_cast<VkDevice>( m_device ),
static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
reinterpret_cast<const void *>( &handle ),
reinterpret_cast<VkMemoryMetalHandlePropertiesEXT *>( &memoryMetalHandleProperties ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandlePropertiesEXT" );
return memoryMetalHandleProperties;
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//====================
//=== RAII Helpers ===
//====================

55
include/vulkan/vulkan_static_assertions.hpp
View file

@ -8146,6 +8146,39 @@ 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_KHR_video_maintenance2 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance2FeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR>::value,
"PhysicalDeviceVideoMaintenance2FeaturesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR ) ==
sizeof( VkVideoDecodeH264InlineSessionParametersInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR>::value,
"VideoDecodeH264InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR ) ==
sizeof( VkVideoDecodeH265InlineSessionParametersInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>::value,
"VideoDecodeH265InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR ) ==
sizeof( VkVideoDecodeAV1InlineSessionParametersInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>::value,
"VideoDecodeAV1InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
//=== VK_HUAWEI_hdr_vivid ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceHdrVividFeaturesHUAWEI ),
@ -8196,6 +8229,28 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>::value,
"PhysicalDevicePipelineOpacityMicromapFeaturesARM is not nothrow_move_constructible!" );
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_external_memory_metal ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT ) == sizeof( VkImportMemoryMetalHandleInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT>::value,
"ImportMemoryMetalHandleInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT ) == sizeof( VkMemoryMetalHandlePropertiesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT>::value,
"MemoryMetalHandlePropertiesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT ) == sizeof( VkMemoryGetMetalHandleInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT>::value,
"MemoryGetMetalHandleInfoEXT is not nothrow_move_constructible!" );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_depth_clamp_zero_one ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR ) == sizeof( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR ),

734
include/vulkan/vulkan_structs.hpp
View file

@ -49147,6 +49147,117 @@ namespace VULKAN_HPP_NAMESPACE
using Type = ImportMemoryHostPointerInfoEXT;
};
#if defined( VK_USE_PLATFORM_METAL_EXT )
struct ImportMemoryMetalHandleInfoEXT
{
using NativeType = VkImportMemoryMetalHandleInfoEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryMetalHandleInfoEXT;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR ImportMemoryMetalHandleInfoEXT(
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
void * handle_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, handleType{ handleType_ }
, handle{ handle_ }
{
}
VULKAN_HPP_CONSTEXPR ImportMemoryMetalHandleInfoEXT( ImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
ImportMemoryMetalHandleInfoEXT( VkImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: ImportMemoryMetalHandleInfoEXT( *reinterpret_cast<ImportMemoryMetalHandleInfoEXT const *>( &rhs ) )
{
}
ImportMemoryMetalHandleInfoEXT & operator=( ImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
ImportMemoryMetalHandleInfoEXT & operator=( VkImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT &
setHandleType( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ ) VULKAN_HPP_NOEXCEPT
{
handleType = handleType_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT & setHandle( void * handle_ ) VULKAN_HPP_NOEXCEPT
{
handle = handle_;
return *this;
}
# endif /*VULKAN_HPP_NO_SETTERS*/
operator VkImportMemoryMetalHandleInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkImportMemoryMetalHandleInfoEXT *>( this );
}
operator VkImportMemoryMetalHandleInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkImportMemoryMetalHandleInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::
tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &, void * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, handleType, handle );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImportMemoryMetalHandleInfoEXT const & ) const = default;
# else
bool operator==( ImportMemoryMetalHandleInfoEXT 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 ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle );
# endif
}
bool operator!=( ImportMemoryMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportMemoryMetalHandleInfoEXT;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
void * handle = {};
};
template <>
struct CppType<StructureType, StructureType::eImportMemoryMetalHandleInfoEXT>
{
using Type = ImportMemoryMetalHandleInfoEXT;
};
#endif /*VK_USE_PLATFORM_METAL_EXT*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct ImportMemoryWin32HandleInfoKHR
{
@ -54749,6 +54860,119 @@ namespace VULKAN_HPP_NAMESPACE
using Type = MemoryGetFdInfoKHR;
};
#if defined( VK_USE_PLATFORM_METAL_EXT )
struct MemoryGetMetalHandleInfoEXT
{
using NativeType = VkMemoryGetMetalHandleInfoEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetMetalHandleInfoEXT;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR MemoryGetMetalHandleInfoEXT(
VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, memory{ memory_ }
, handleType{ handleType_ }
{
}
VULKAN_HPP_CONSTEXPR MemoryGetMetalHandleInfoEXT( MemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
MemoryGetMetalHandleInfoEXT( VkMemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: MemoryGetMetalHandleInfoEXT( *reinterpret_cast<MemoryGetMetalHandleInfoEXT const *>( &rhs ) )
{
}
MemoryGetMetalHandleInfoEXT & operator=( MemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
MemoryGetMetalHandleInfoEXT & operator=( VkMemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT & setMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ ) VULKAN_HPP_NOEXCEPT
{
memory = memory_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT &
setHandleType( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ ) VULKAN_HPP_NOEXCEPT
{
handleType = handleType_;
return *this;
}
# endif /*VULKAN_HPP_NO_SETTERS*/
operator VkMemoryGetMetalHandleInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT *>( this );
}
operator VkMemoryGetMetalHandleInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryGetMetalHandleInfoEXT *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
VULKAN_HPP_NAMESPACE::DeviceMemory const &,
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, memory, handleType );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryGetMetalHandleInfoEXT const & ) const = default;
# else
bool operator==( MemoryGetMetalHandleInfoEXT 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 ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType );
# endif
}
bool operator!=( MemoryGetMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryGetMetalHandleInfoEXT;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
};
template <>
struct CppType<StructureType, StructureType::eMemoryGetMetalHandleInfoEXT>
{
using Type = MemoryGetMetalHandleInfoEXT;
};
#endif /*VK_USE_PLATFORM_METAL_EXT*/
struct MemoryGetRemoteAddressInfoNV
{
using NativeType = VkMemoryGetRemoteAddressInfoNV;
@ -55462,6 +55686,90 @@ namespace VULKAN_HPP_NAMESPACE
using Type = MemoryMapPlacedInfoEXT;
};
#if defined( VK_USE_PLATFORM_METAL_EXT )
struct MemoryMetalHandlePropertiesEXT
{
using NativeType = VkMemoryMetalHandlePropertiesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMetalHandlePropertiesEXT;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR MemoryMetalHandlePropertiesEXT( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, memoryTypeBits{ memoryTypeBits_ }
{
}
VULKAN_HPP_CONSTEXPR MemoryMetalHandlePropertiesEXT( MemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
MemoryMetalHandlePropertiesEXT( VkMemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: MemoryMetalHandlePropertiesEXT( *reinterpret_cast<MemoryMetalHandlePropertiesEXT const *>( &rhs ) )
{
}
MemoryMetalHandlePropertiesEXT & operator=( MemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
MemoryMetalHandlePropertiesEXT & operator=( VkMemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT const *>( &rhs );
return *this;
}
operator VkMemoryMetalHandlePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryMetalHandlePropertiesEXT *>( this );
}
operator VkMemoryMetalHandlePropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryMetalHandlePropertiesEXT *>( 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 &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, memoryTypeBits );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryMetalHandlePropertiesEXT const & ) const = default;
# else
bool operator==( MemoryMetalHandlePropertiesEXT 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 ) && ( memoryTypeBits == rhs.memoryTypeBits );
# endif
}
bool operator!=( MemoryMetalHandlePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryMetalHandlePropertiesEXT;
void * pNext = {};
uint32_t memoryTypeBits = {};
};
template <>
struct CppType<StructureType, StructureType::eMemoryMetalHandlePropertiesEXT>
{
using Type = MemoryMetalHandlePropertiesEXT;
};
#endif /*VK_USE_PLATFORM_METAL_EXT*/
struct MemoryOpaqueCaptureAddressAllocateInfo
{
using NativeType = VkMemoryOpaqueCaptureAddressAllocateInfo;
@ -94973,6 +95281,104 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceVideoMaintenance1FeaturesKHR;
};
struct PhysicalDeviceVideoMaintenance2FeaturesKHR
{
using NativeType = VkPhysicalDeviceVideoMaintenance2FeaturesKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance2FeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 videoMaintenance2_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, videoMaintenance2{ videoMaintenance2_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance2FeaturesKHR( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceVideoMaintenance2FeaturesKHR( VkPhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceVideoMaintenance2FeaturesKHR( *reinterpret_cast<PhysicalDeviceVideoMaintenance2FeaturesKHR const *>( &rhs ) )
{
}
PhysicalDeviceVideoMaintenance2FeaturesKHR & operator=( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceVideoMaintenance2FeaturesKHR & operator=( VkPhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR &
setVideoMaintenance2( VULKAN_HPP_NAMESPACE::Bool32 videoMaintenance2_ ) VULKAN_HPP_NOEXCEPT
{
videoMaintenance2 = videoMaintenance2_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>( this );
}
operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>( 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 &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, videoMaintenance2 );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceVideoMaintenance2FeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceVideoMaintenance2FeaturesKHR 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 ) && ( videoMaintenance2 == rhs.videoMaintenance2 );
# endif
}
bool operator!=( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 videoMaintenance2 = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR>
{
using Type = PhysicalDeviceVideoMaintenance2FeaturesKHR;
};
struct PhysicalDeviceVulkan11Features
{
using NativeType = VkPhysicalDeviceVulkan11Features;
@ -124239,6 +124645,104 @@ namespace VULKAN_HPP_NAMESPACE
using Type = VideoDecodeAV1DpbSlotInfoKHR;
};
struct VideoDecodeAV1InlineSessionParametersInfoKHR
{
using NativeType = VkVideoDecodeAV1InlineSessionParametersInfoKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoDecodeAV1InlineSessionParametersInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, pStdSequenceHeader{ pStdSequenceHeader_ }
{
}
VULKAN_HPP_CONSTEXPR VideoDecodeAV1InlineSessionParametersInfoKHR( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VideoDecodeAV1InlineSessionParametersInfoKHR( VkVideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: VideoDecodeAV1InlineSessionParametersInfoKHR( *reinterpret_cast<VideoDecodeAV1InlineSessionParametersInfoKHR const *>( &rhs ) )
{
}
VideoDecodeAV1InlineSessionParametersInfoKHR & operator=( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
VideoDecodeAV1InlineSessionParametersInfoKHR & operator=( VkVideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR &
setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) VULKAN_HPP_NOEXCEPT
{
pStdSequenceHeader = pStdSequenceHeader_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkVideoDecodeAV1InlineSessionParametersInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeAV1InlineSessionParametersInfoKHR *>( this );
}
operator VkVideoDecodeAV1InlineSessionParametersInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeAV1InlineSessionParametersInfoKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, const StdVideoAV1SequenceHeader * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, pStdSequenceHeader );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeAV1InlineSessionParametersInfoKHR const & ) const = default;
#else
bool operator==( VideoDecodeAV1InlineSessionParametersInfoKHR 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 ) && ( pStdSequenceHeader == rhs.pStdSequenceHeader );
# endif
}
bool operator!=( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR;
const void * pNext = {};
const StdVideoAV1SequenceHeader * pStdSequenceHeader = {};
};
template <>
struct CppType<StructureType, StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR>
{
using Type = VideoDecodeAV1InlineSessionParametersInfoKHR;
};
struct VideoDecodeAV1PictureInfoKHR
{
using NativeType = VkVideoDecodeAV1PictureInfoKHR;
@ -124925,6 +125429,116 @@ namespace VULKAN_HPP_NAMESPACE
using Type = VideoDecodeH264DpbSlotInfoKHR;
};
struct VideoDecodeH264InlineSessionParametersInfoKHR
{
using NativeType = VkVideoDecodeH264InlineSessionParametersInfoKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoDecodeH264InlineSessionParametersInfoKHR( const StdVideoH264SequenceParameterSet * pStdSPS_ = {},
const StdVideoH264PictureParameterSet * pStdPPS_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, pStdSPS{ pStdSPS_ }
, pStdPPS{ pStdPPS_ }
{
}
VULKAN_HPP_CONSTEXPR
VideoDecodeH264InlineSessionParametersInfoKHR( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VideoDecodeH264InlineSessionParametersInfoKHR( VkVideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: VideoDecodeH264InlineSessionParametersInfoKHR( *reinterpret_cast<VideoDecodeH264InlineSessionParametersInfoKHR const *>( &rhs ) )
{
}
VideoDecodeH264InlineSessionParametersInfoKHR & operator=( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
VideoDecodeH264InlineSessionParametersInfoKHR & operator=( VkVideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR & setPStdSPS( const StdVideoH264SequenceParameterSet * pStdSPS_ ) VULKAN_HPP_NOEXCEPT
{
pStdSPS = pStdSPS_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR & setPStdPPS( const StdVideoH264PictureParameterSet * pStdPPS_ ) VULKAN_HPP_NOEXCEPT
{
pStdPPS = pStdPPS_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkVideoDecodeH264InlineSessionParametersInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH264InlineSessionParametersInfoKHR *>( this );
}
operator VkVideoDecodeH264InlineSessionParametersInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH264InlineSessionParametersInfoKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
const StdVideoH264SequenceParameterSet * const &,
const StdVideoH264PictureParameterSet * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, pStdSPS, pStdPPS );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH264InlineSessionParametersInfoKHR const & ) const = default;
#else
bool operator==( VideoDecodeH264InlineSessionParametersInfoKHR 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 ) && ( pStdSPS == rhs.pStdSPS ) && ( pStdPPS == rhs.pStdPPS );
# endif
}
bool operator!=( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR;
const void * pNext = {};
const StdVideoH264SequenceParameterSet * pStdSPS = {};
const StdVideoH264PictureParameterSet * pStdPPS = {};
};
template <>
struct CppType<StructureType, StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR>
{
using Type = VideoDecodeH264InlineSessionParametersInfoKHR;
};
struct VideoDecodeH264PictureInfoKHR
{
using NativeType = VkVideoDecodeH264PictureInfoKHR;
@ -125655,6 +126269,126 @@ namespace VULKAN_HPP_NAMESPACE
using Type = VideoDecodeH265DpbSlotInfoKHR;
};
struct VideoDecodeH265InlineSessionParametersInfoKHR
{
using NativeType = VkVideoDecodeH265InlineSessionParametersInfoKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoDecodeH265InlineSessionParametersInfoKHR( const StdVideoH265VideoParameterSet * pStdVPS_ = {},
const StdVideoH265SequenceParameterSet * pStdSPS_ = {},
const StdVideoH265PictureParameterSet * pStdPPS_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, pStdVPS{ pStdVPS_ }
, pStdSPS{ pStdSPS_ }
, pStdPPS{ pStdPPS_ }
{
}
VULKAN_HPP_CONSTEXPR
VideoDecodeH265InlineSessionParametersInfoKHR( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VideoDecodeH265InlineSessionParametersInfoKHR( VkVideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: VideoDecodeH265InlineSessionParametersInfoKHR( *reinterpret_cast<VideoDecodeH265InlineSessionParametersInfoKHR const *>( &rhs ) )
{
}
VideoDecodeH265InlineSessionParametersInfoKHR & operator=( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
VideoDecodeH265InlineSessionParametersInfoKHR & operator=( VkVideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPStdVPS( const StdVideoH265VideoParameterSet * pStdVPS_ ) VULKAN_HPP_NOEXCEPT
{
pStdVPS = pStdVPS_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPStdSPS( const StdVideoH265SequenceParameterSet * pStdSPS_ ) VULKAN_HPP_NOEXCEPT
{
pStdSPS = pStdSPS_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPStdPPS( const StdVideoH265PictureParameterSet * pStdPPS_ ) VULKAN_HPP_NOEXCEPT
{
pStdPPS = pStdPPS_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkVideoDecodeH265InlineSessionParametersInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeH265InlineSessionParametersInfoKHR *>( this );
}
operator VkVideoDecodeH265InlineSessionParametersInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeH265InlineSessionParametersInfoKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
const StdVideoH265VideoParameterSet * const &,
const StdVideoH265SequenceParameterSet * const &,
const StdVideoH265PictureParameterSet * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, pStdVPS, pStdSPS, pStdPPS );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeH265InlineSessionParametersInfoKHR const & ) const = default;
#else
bool operator==( VideoDecodeH265InlineSessionParametersInfoKHR 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 ) && ( pStdVPS == rhs.pStdVPS ) && ( pStdSPS == rhs.pStdSPS ) && ( pStdPPS == rhs.pStdPPS );
# endif
}
bool operator!=( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR;
const void * pNext = {};
const StdVideoH265VideoParameterSet * pStdVPS = {};
const StdVideoH265SequenceParameterSet * pStdSPS = {};
const StdVideoH265PictureParameterSet * pStdPPS = {};
};
template <>
struct CppType<StructureType, StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR>
{
using Type = VideoDecodeH265InlineSessionParametersInfoKHR;
};
struct VideoDecodeH265PictureInfoKHR
{
using NativeType = VkVideoDecodeH265PictureInfoKHR;

25
include/vulkan/vulkan_to_string.hpp
View file

@ -1343,6 +1343,14 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX )
result += "ScreenBufferQNX | ";
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
if ( value & ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT )
result += "MtlbufferEXT | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eMtltextureEXT )
result += "MtltextureEXT | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eMtlheapEXT )
result += "MtlheapEXT | ";
#endif /*VK_USE_PLATFORM_METAL_EXT*/
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
@ -2323,6 +2331,8 @@ namespace VULKAN_HPP_NAMESPACE
result += "AllowEncodeQuantizationDeltaMap | ";
if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap )
result += "AllowEncodeEmphasisMap | ";
if ( value & VideoSessionCreateFlagBitsKHR::eInlineSessionParameters )
result += "InlineSessionParameters | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
@ -4804,12 +4814,21 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eImageAlignmentControlCreateInfoMESA: return "ImageAlignmentControlCreateInfoMESA";
case StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT: return "PhysicalDeviceDepthClampControlFeaturesEXT";
case StructureType::ePipelineViewportDepthClampControlCreateInfoEXT: return "PipelineViewportDepthClampControlCreateInfoEXT";
case StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR: return "PhysicalDeviceVideoMaintenance2FeaturesKHR";
case StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR: return "VideoDecodeH264InlineSessionParametersInfoKHR";
case StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR: return "VideoDecodeH265InlineSessionParametersInfoKHR";
case StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR: return "VideoDecodeAv1InlineSessionParametersInfoKHR";
case StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI: return "PhysicalDeviceHdrVividFeaturesHUAWEI";
case StructureType::eHdrVividDynamicMetadataHUAWEI: return "HdrVividDynamicMetadataHUAWEI";
case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV: return "PhysicalDeviceCooperativeMatrix2FeaturesNV";
case StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV: return "CooperativeMatrixFlexibleDimensionsPropertiesNV";
case StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV: return "PhysicalDeviceCooperativeMatrix2PropertiesNV";
case StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM: return "PhysicalDevicePipelineOpacityMicromapFeaturesARM";
#if defined( VK_USE_PLATFORM_METAL_EXT )
case StructureType::eImportMemoryMetalHandleInfoEXT: return "ImportMemoryMetalHandleInfoEXT";
case StructureType::eMemoryMetalHandlePropertiesEXT: return "MemoryMetalHandlePropertiesEXT";
case StructureType::eMemoryGetMetalHandleInfoEXT: return "MemoryGetMetalHandleInfoEXT";
#endif /*VK_USE_PLATFORM_METAL_EXT*/
case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR: return "PhysicalDeviceDepthClampZeroOneFeaturesKHR";
case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT: return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
@ -6658,6 +6677,11 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
case ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX: return "ScreenBufferQNX";
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
case ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT: return "MtlbufferEXT";
case ExternalMemoryHandleTypeFlagBits::eMtltextureEXT: return "MtltextureEXT";
case ExternalMemoryHandleTypeFlagBits::eMtlheapEXT: return "MtlheapEXT";
#endif /*VK_USE_PLATFORM_METAL_EXT*/
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -7513,6 +7537,7 @@ namespace VULKAN_HPP_NAMESPACE
case VideoSessionCreateFlagBitsKHR::eInlineQueries: return "InlineQueries";
case VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap: return "AllowEncodeQuantizationDeltaMap";
case VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap: return "AllowEncodeEmphasisMap";
case VideoSessionCreateFlagBitsKHR::eInlineSessionParameters: return "InlineSessionParameters";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}

785
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

123
registry/vk.xml Normal file → Executable file
View file

@ -179,7 +179,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> 305</type>
#define <name>VK_HEADER_VERSION</name> 306</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, 4, VK_HEADER_VERSION)</type>
<type api="vulkansc" category="define">// Version of this file
@ -2863,6 +2863,23 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member len="releaseCount">const <type>VkDeviceMemory</type>* <name>pReleaseSyncs</name></member>
<member len="releaseCount">const <type>uint64_t</type>* <name>pReleaseKeys</name></member>
</type>
<type category="struct" name="VkImportMemoryMetalHandleInfoEXT" structextends="VkMemoryAllocateInfo">
<member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
<member optional="true"><type>void</type>* <name>handle</name></member>
</type>
<type category="struct" name="VkMemoryMetalHandlePropertiesEXT" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>uint32_t</type> <name>memoryTypeBits</name></member>
</type>
<type category="struct" name="VkMemoryGetMetalHandleInfoEXT">
<member values="VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkDeviceMemory</type> <name>memory</name></member>
<member><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceExternalSemaphoreInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
@ -7199,6 +7216,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>videoMaintenance1</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceVideoMaintenance2FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>videoMaintenance2</name></member>
</type>
<type category="struct" name="VkVideoInlineQueryInfoKHR" structextends="VkVideoDecodeInfoKHR,VkVideoEncodeInfoKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
@ -7242,6 +7264,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>uint32_t</type> <name>maxStdPPSCount</name></member>
<member optional="true">const <type>VkVideoDecodeH264SessionParametersAddInfoKHR</type>* <name>pParametersAddInfo</name></member>
</type>
<type category="struct" name="VkVideoDecodeH264InlineSessionParametersInfoKHR" structextends="VkVideoDecodeInfoKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true">const <type>StdVideoH264SequenceParameterSet</type>* <name>pStdSPS</name></member>
<member optional="true">const <type>StdVideoH264PictureParameterSet</type>* <name>pStdPPS</name></member>
</type>
<type category="struct" name="VkVideoDecodeH264PictureInfoKHR" structextends="VkVideoDecodeInfoKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
@ -7291,6 +7319,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>uint32_t</type> <name>maxStdPPSCount</name></member>
<member optional="true">const <type>VkVideoDecodeH265SessionParametersAddInfoKHR</type>* <name>pParametersAddInfo</name></member>
</type>
<type category="struct" name="VkVideoDecodeH265InlineSessionParametersInfoKHR" structextends="VkVideoDecodeInfoKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true">const <type>StdVideoH265VideoParameterSet</type>* <name>pStdVPS</name></member>
<member optional="true">const <type>StdVideoH265SequenceParameterSet</type>* <name>pStdSPS</name></member>
<member optional="true">const <type>StdVideoH265PictureParameterSet</type>* <name>pStdPPS</name></member>
</type>
<type category="struct" name="VkVideoDecodeH265PictureInfoKHR" structextends="VkVideoDecodeInfoKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
@ -7326,6 +7361,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member>const <type>StdVideoAV1SequenceHeader</type>* <name>pStdSequenceHeader</name></member>
</type>
<type category="struct" name="VkVideoDecodeAV1InlineSessionParametersInfoKHR" structextends="VkVideoDecodeInfoKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true">const <type>StdVideoAV1SequenceHeader</type>* <name>pStdSequenceHeader</name></member>
</type>
<type category="struct" name="VkVideoDecodeAV1PictureInfoKHR" structextends="VkVideoDecodeInfoKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
@ -16227,6 +16267,19 @@ typedef void* <name>MTLSharedEvent_id</name>;
<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>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
<proto><type>VkResult</type> <name>vkGetMemoryMetalHandleEXT</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param>const <type>VkMemoryGetMetalHandleInfoEXT</type>* <name>pGetMetalHandleInfo</name></param>
<param><type>void</type>** <name>pHandle</name></param>
</command>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE">
<proto><type>VkResult</type> <name>vkGetMemoryMetalHandlePropertiesEXT</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param><type>VkExternalMemoryHandleTypeFlagBits</type> <name>handleType</name></param>
<param>const <type>void</type>* <name>pHandle</name></param>
<param><type>VkMemoryMetalHandlePropertiesEXT</type>* <name>pMemoryMetalHandleProperties</name></param>
</command>
</commands>
<feature api="vulkan,vulkansc" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
@ -19058,7 +19111,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkPhysicalDeviceASTCDecodeFeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_pipeline_robustness" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" number="69" type="device" author="IMG" contact="Jarred Davies" supported="vulkan" promotedto="VK_VERSION_1_4">
<extension name="VK_EXT_pipeline_robustness" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" number="69" type="device" author="IMG" contact="Jarred Davies" supported="vulkan" ratified="vulkan" promotedto="VK_VERSION_1_4">
<require>
<enum value="1" name="VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_pipeline_robustness&quot;" name="VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME"/>
@ -23157,7 +23210,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkCmdResolveImage2KHR"/>
</require>
</extension>
<extension name="VK_EXT_image_compression_control" number="339" type="device" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan">
<extension name="VK_EXT_image_compression_control" number="339" type="device" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_image_compression_control&quot;" name="VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME"/>
@ -24320,7 +24373,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_437&quot;" name="VK_EXT_EXTENSION_437_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_image_compression_control_swapchain" number="438" type="device" depends="VK_EXT_image_compression_control" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan">
<extension name="VK_EXT_image_compression_control_swapchain" number="438" type="device" depends="VK_EXT_image_compression_control" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_image_compression_control_swapchain&quot;" name="VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME"/>
@ -24605,7 +24658,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_458&quot;" name="VK_EXT_EXTENSION_458_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_subpass_merge_feedback" number="459" type="device" author="EXT" contact="Ting Wei @catweiting" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan">
<extension name="VK_EXT_subpass_merge_feedback" number="459" type="device" author="EXT" contact="Ting Wei @catweiting" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan" ratified="vulkan">
<require>
<enum value="2" name="VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_subpass_merge_feedback&quot;" name="VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME"/>
@ -24668,7 +24721,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="shaderModuleIdentifier" struct="VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_rasterization_order_attachment_access" number="464" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan" nofeatures="true">
<extension name="VK_EXT_rasterization_order_attachment_access" number="464" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan" ratified="vulkan" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_rasterization_order_attachment_access&quot;" name="VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME"/>
@ -25304,7 +25357,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_NV_extension_494&quot;" name="VK_NV_EXTENSION_494_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_mutable_descriptor_type" number="495" type="device" supported="vulkan" author="EXT" contact="Joshua Ashton @Joshua-Ashton,Hans-Kristian Arntzen @HansKristian-Work" specialuse="d3demulation" depends="VK_KHR_maintenance3">
<extension name="VK_EXT_mutable_descriptor_type" number="495" type="device" supported="vulkan" ratified="vulkan" author="EXT" contact="Joshua Ashton @Joshua-Ashton,Hans-Kristian Arntzen @HansKristian-Work" specialuse="d3demulation" depends="VK_KHR_maintenance3">
<require>
<enum value="1" name="VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_mutable_descriptor_type&quot;" name="VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME"/>
@ -25888,7 +25941,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<require>
<enum value="0" name="VK_QCOM_EXTENSION_548_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_extension_548&quot;" name="VK_QCOM_EXTENSION_548_EXTENSION_NAME"/>
<enum bitpos="9" extends="VkMemoryPropertyFlagBits" name="VK_MEMORY_PROPERTY_RESERVED_9_QCOM"/>
<enum bitpos="3" extends="VkMemoryHeapFlagBits" name="VK_MEMORY_HEAP_RESERVED_3_QCOM"/>
<enum bitpos="27" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_27_BIT_QCOM"/>
<enum bitpos="27" extends="VkBufferUsageFlagBits2" name="VK_BUFFER_USAGE_2_RESERVED_27_BIT_QCOM"/>
<enum bitpos="27" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_27_QCOM"/>
@ -25914,6 +25967,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="45" extends="VkPipelineStageFlagBits2" name="VK_PIPELINE_STAGE_2_RESERVED_45_BIT_NV"/>
<enum bitpos="55" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_55_BIT_NV"/>
<enum bitpos="56" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_56_BIT_NV"/>
<enum bitpos="32" extends="VkBufferUsageFlagBits2" name="VK_BUFFER_USAGE_2_RESERVED_32_BIT_NV"/>
</require>
</extension>
<extension name="VK_NV_display_stereo" number="552" type="instance" depends="VK_KHR_display+VK_KHR_get_display_properties2" author="NV" contact="Russell Chou @russellcnv" supported="vulkan" nofeatures="true">
@ -26311,12 +26365,28 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="4" extends="VkDependencyFlagBits" name="VK_DEPENDENCY_EXTENSION_586_BIT_IMG"/>
</require>
</extension>
<extension name="VK_KHR_extension_587" number="587" author="KHR" contact="Daniel Rakos @aqnuep" supported="disabled">
<extension name="VK_KHR_video_maintenance2" number="587" author="KHR" contact="Daniel Rakos @aqnuep" type="device" depends="VK_KHR_video_decode_queue,VK_KHR_video_encode_queue" supported="vulkan" ratified="vulkan">
<require>
<enum value="0" name="VK_KHR_EXTENSION_587_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_extension_587&quot;" name="VK_KHR_EXTENSION_587_EXTENSION_NAME"/>
<enum bitpos="5" extends="VkVideoSessionCreateFlagBitsKHR" name="VK_VIDEO_SESSION_CREATE_RESERVED_5_BIT_KHR"/>
<enum bitpos="6" extends="VkVideoSessionCreateFlagBitsKHR" name="VK_VIDEO_SESSION_CREATE_RESERVED_6_BIT_KHR"/>
<enum value="1" name="VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_video_maintenance2&quot;" name="VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR"/>
<type name="VkPhysicalDeviceVideoMaintenance2FeaturesKHR"/>
<feature name="videoMaintenance2" struct="VkPhysicalDeviceVideoMaintenance2FeaturesKHR"/>
</require>
<require depends="VK_KHR_video_decode_queue">
<enum bitpos="5" extends="VkVideoSessionCreateFlagBitsKHR" name="VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR"/>
</require>
<require depends="VK_KHR_video_decode_h264">
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR"/>
<type name="VkVideoDecodeH264InlineSessionParametersInfoKHR"/>
</require>
<require depends="VK_KHR_video_decode_h265">
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR"/>
<type name="VkVideoDecodeH265InlineSessionParametersInfoKHR"/>
</require>
<require depends="VK_KHR_video_decode_av1">
<enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR"/>
<type name="VkVideoDecodeAV1InlineSessionParametersInfoKHR"/>
</require>
</extension>
<extension name="VK_HUAWEI_extension_588" number="588" author="HUAWEI" contact="Pan Gao @pangao-h" supported="disabled">
@ -26428,12 +26498,21 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_602&quot;" name="VK_EXT_EXTENSION_602_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_603" number="603" author="EXT" contact="Aitor Camacho Larrondo @aitor-lunarg" supported="disabled">
<extension name="VK_EXT_external_memory_metal" number="603" type="device" depends="VK_KHR_external_memory,VK_VERSION_1_1" author="EXT" contact="Aitor Camacho Larrondo @aitor-lunarg" platform="metal" supported="vulkan" nofeatures="true">
<require>
<enum value="0" name="VK_EXT_EXTENSION_603_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_603&quot;" name="VK_EXT_EXTENSION_603_EXTENSION_NAME"/>
<enum bitpos="16" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_603_BIT_EXT"/>
<enum bitpos="17" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_603_BIT_2_EXT"/>
<enum value="1" name="VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_external_memory_metal&quot;" name="VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT"/>
<enum bitpos="16" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT"/>
<enum bitpos="17" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT"/>
<enum bitpos="18" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT"/>
<type name="VkImportMemoryMetalHandleInfoEXT"/>
<type name="VkMemoryMetalHandlePropertiesEXT"/>
<type name="VkMemoryGetMetalHandleInfoEXT"/>
<command name="vkGetMemoryMetalHandleEXT"/>
<command name="vkGetMemoryMetalHandlePropertiesEXT"/>
</require>
</extension>
<extension name="VK_EXT_extension_604" number="604" author="EXT" contact="Colin Marc @colinmarc" supported="disabled">
@ -26506,7 +26585,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<extension name="VK_NV_extension_614" number="614" author="NV" contact="Charles Hansen @cshansen" supported="disabled">
<require>
<enum value="0" name="VK_NV_EXTENSION_614_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extension_614&quot;" name="VK_NV_EXTENSION_614_EXTENSION_NAME"/>
<enum value="&quot;VK_NV_extension_614&quot;" name="VK_NV_EXTENSION_614_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_QCOM_extension_615" number="615" author="QCOM" contact="Matthew Netsch @mnetsch" supported="disabled">
<require>
<enum value="0" name="VK_QCOM_EXTENSION_615_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_extension_615&quot;" name="VK_QCOM_EXTENSION_615_EXTENSION_NAME"/>
</require>
</extension>
</extensions>