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

Update for Vulkan-Docs 1.3.273

Browse source
This commit is contained in:
Jon Leech 2023-12-08 06:22:27 -08:00 committed by Jon Leech
parent 19a863ccce
commit 41263fc5aa
17 changed files with 5224 additions and 2061 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
include/vulkan/vulkan.cppm
View file

@ -593,9 +593,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagBitsAMD; using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagBitsAMD;
using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD; using VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD;
//=== VK_EXT_calibrated_timestamps ===
using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
//=== VK_KHR_global_priority === //=== VK_KHR_global_priority ===
using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT; using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT;
using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR; using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR;
@ -848,6 +845,10 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_MSFT_layered_driver === //=== VK_MSFT_layered_driver ===
using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT; using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT;
//=== VK_KHR_calibrated_timestamps ===
using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
using VULKAN_HPP_NAMESPACE::TimeDomainKHR;
//========================= //=========================
//=== Index Type Traits === //=== Index Type Traits ===
//========================= //=========================
@ -2429,6 +2430,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopDynamicStateExtensionName; using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopDynamicStateExtensionName;
using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopDynamicStateSpecVersion; using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopDynamicStateSpecVersion;
//=== VK_KHR_vertex_attribute_divisor ===
using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorExtensionName;
using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorSpecVersion;
#if defined( VK_USE_PLATFORM_SCREEN_QNX ) #if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer === //=== VK_QNX_external_memory_screen_buffer ===
using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferExtensionName; using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferExtensionName;
@ -2439,6 +2444,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverExtensionName; using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverExtensionName;
using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverSpecVersion; using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverSpecVersion;
//=== VK_KHR_calibrated_timestamps ===
using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsExtensionName;
using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsSpecVersion;
//=== VK_NV_descriptor_pool_overallocation === //=== VK_NV_descriptor_pool_overallocation ===
using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName; using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName;
using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion; using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion;
@ -3431,9 +3440,6 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_AMD_pipeline_compiler_control === //=== VK_AMD_pipeline_compiler_control ===
using VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD; using VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD;
//=== VK_EXT_calibrated_timestamps ===
using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT;
//=== VK_AMD_shader_core_properties === //=== VK_AMD_shader_core_properties ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD; using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD;
@ -3457,10 +3463,7 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD; using VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD;
//=== VK_EXT_vertex_attribute_divisor === //=== VK_EXT_vertex_attribute_divisor ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT; using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT;
using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT;
#if defined( VK_USE_PLATFORM_GGP ) #if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_frame_token === //=== VK_GGP_frame_token ===
@ -4210,6 +4213,15 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_attachment_feedback_loop_dynamic_state === //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
//=== VK_KHR_vertex_attribute_divisor ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR;
using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT;
using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR;
using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT;
using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR;
#if defined( VK_USE_PLATFORM_SCREEN_QNX ) #if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer === //=== VK_QNX_external_memory_screen_buffer ===
using VULKAN_HPP_NAMESPACE::ExternalFormatQNX; using VULKAN_HPP_NAMESPACE::ExternalFormatQNX;
@ -4222,6 +4234,10 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_MSFT_layered_driver === //=== VK_MSFT_layered_driver ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT; using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT;
//=== VK_KHR_calibrated_timestamps ===
using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT;
using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR;
//=== VK_NV_descriptor_pool_overallocation === //=== VK_NV_descriptor_pool_overallocation ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;

789
include/vulkan/vulkan.hpp
View file

File diff suppressed because it is too large Load diff

133
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 #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 // Version of this file
#define VK_HEADER_VERSION 272 #define VK_HEADER_VERSION 273
// Complete version of this file // Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@ -733,7 +733,6 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000,
VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001,
@ -746,8 +745,6 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001,
VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
@ -1152,12 +1149,16 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = 1000525000,
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = 1000190001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = 1000190002,
VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000, VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000,
VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001, VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001,
VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002, VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002,
VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000,
VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
@ -1259,6 +1260,9 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR,
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR,
VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
@ -10741,6 +10745,78 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR
#endif #endif
// VK_KHR_vertex_attribute_divisor is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_vertex_attribute_divisor 1
#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1
#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_KHR_vertex_attribute_divisor"
typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR {
VkStructureType sType;
void* pNext;
uint32_t maxVertexAttribDivisor;
VkBool32 supportsNonZeroFirstInstance;
} VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR;
typedef struct VkVertexInputBindingDivisorDescriptionKHR {
uint32_t binding;
uint32_t divisor;
} VkVertexInputBindingDivisorDescriptionKHR;
typedef struct VkPipelineVertexInputDivisorStateCreateInfoKHR {
VkStructureType sType;
const void* pNext;
uint32_t vertexBindingDivisorCount;
const VkVertexInputBindingDivisorDescriptionKHR* pVertexBindingDivisors;
} VkPipelineVertexInputDivisorStateCreateInfoKHR;
typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 vertexAttributeInstanceRateDivisor;
VkBool32 vertexAttributeInstanceRateZeroDivisor;
} VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR;
// VK_KHR_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_calibrated_timestamps 1
#define VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1
#define VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_KHR_calibrated_timestamps"
typedef enum VkTimeDomainKHR {
VK_TIME_DOMAIN_DEVICE_KHR = 0,
VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR = 1,
VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR = 2,
VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR = 3,
VK_TIME_DOMAIN_DEVICE_EXT = VK_TIME_DOMAIN_DEVICE_KHR,
VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR,
VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR,
VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR,
VK_TIME_DOMAIN_MAX_ENUM_KHR = 0x7FFFFFFF
} VkTimeDomainKHR;
typedef struct VkCalibratedTimestampInfoKHR {
VkStructureType sType;
const void* pNext;
VkTimeDomainKHR timeDomain;
} VkCalibratedTimestampInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains);
typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsKHR)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(
VkPhysicalDevice physicalDevice,
uint32_t* pTimeDomainCount,
VkTimeDomainKHR* pTimeDomains);
VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR(
VkDevice device,
uint32_t timestampCount,
const VkCalibratedTimestampInfoKHR* pTimestampInfos,
uint64_t* pTimestamps,
uint64_t* pMaxDeviation);
#endif
// VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_debug_report 1 #define VK_EXT_debug_report 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
@ -13079,33 +13155,23 @@ typedef struct VkPipelineCompilerControlCreateInfoAMD {
#define VK_EXT_calibrated_timestamps 1 #define VK_EXT_calibrated_timestamps 1
#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2 #define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2
#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps" #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
typedef VkTimeDomainKHR VkTimeDomainEXT;
typedef enum VkTimeDomainEXT { typedef VkCalibratedTimestampInfoKHR VkCalibratedTimestampInfoEXT;
VK_TIME_DOMAIN_DEVICE_EXT = 0,
VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,
VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,
VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,
VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
} VkTimeDomainEXT;
typedef struct VkCalibratedTimestampInfoEXT {
VkStructureType sType;
const void* pNext;
VkTimeDomainEXT timeDomain;
} VkCalibratedTimestampInfoEXT;
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains);
typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
VkPhysicalDevice physicalDevice, VkPhysicalDevice physicalDevice,
uint32_t* pTimeDomainCount, uint32_t* pTimeDomainCount,
VkTimeDomainEXT* pTimeDomains); VkTimeDomainKHR* pTimeDomains);
VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(
VkDevice device, VkDevice device,
uint32_t timestampCount, uint32_t timestampCount,
const VkCalibratedTimestampInfoEXT* pTimestampInfos, const VkCalibratedTimestampInfoKHR* pTimestampInfos,
uint64_t* pTimestamps, uint64_t* pTimestamps,
uint64_t* pMaxDeviation); uint64_t* pMaxDeviation);
#endif #endif
@ -13165,24 +13231,11 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
uint32_t maxVertexAttribDivisor; uint32_t maxVertexAttribDivisor;
} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
typedef struct VkVertexInputBindingDivisorDescriptionEXT { typedef VkVertexInputBindingDivisorDescriptionKHR VkVertexInputBindingDivisorDescriptionEXT;
uint32_t binding;
uint32_t divisor;
} VkVertexInputBindingDivisorDescriptionEXT;
typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { typedef VkPipelineVertexInputDivisorStateCreateInfoKHR VkPipelineVertexInputDivisorStateCreateInfoEXT;
VkStructureType sType;
const void* pNext;
uint32_t vertexBindingDivisorCount;
const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;
} VkPipelineVertexInputDivisorStateCreateInfoEXT;
typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { typedef VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
VkStructureType sType;
void* pNext;
VkBool32 vertexAttributeInstanceRateDivisor;
VkBool32 vertexAttributeInstanceRateZeroDivisor;
} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
@ -16611,10 +16664,10 @@ typedef struct VkPhysicalDeviceShaderCorePropertiesARM {
#define VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME "VK_ARM_scheduling_controls" #define VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME "VK_ARM_scheduling_controls"
typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM;
typedef enum VkPhysicalDeviceSchedulingControlsFlagBitsARM { // Flag bits for VkPhysicalDeviceSchedulingControlsFlagBitsARM
VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001, typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagBitsARM;
VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF static const VkPhysicalDeviceSchedulingControlsFlagBitsARM VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001ULL;
} VkPhysicalDeviceSchedulingControlsFlagBitsARM;
typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM { typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM {
VkStructureType sType; VkStructureType sType;
void* pNext; void* pNext;

35
include/vulkan/vulkan_enums.hpp
View file

@ -1382,6 +1382,9 @@ namespace VULKAN_HPP_NAMESPACE
eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM, eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM,
ePhysicalDeviceCubicClampFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, ePhysicalDeviceCubicClampFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM,
ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT,
ePhysicalDeviceVertexAttributeDivisorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR,
ePipelineVertexInputDivisorStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR,
ePhysicalDeviceVertexAttributeDivisorFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR,
#if defined( VK_USE_PLATFORM_SCREEN_QNX ) #if defined( VK_USE_PLATFORM_SCREEN_QNX )
eScreenBufferPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX, eScreenBufferPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX,
eScreenBufferFormatPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX, eScreenBufferFormatPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX,
@ -1390,6 +1393,7 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX, ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
ePhysicalDeviceLayeredDriverPropertiesMSFT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT, ePhysicalDeviceLayeredDriverPropertiesMSFT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT,
eCalibratedTimestampInfoKHR = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR,
ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV
}; };
@ -2053,9 +2057,9 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR QueueFlags allFlags = QueueFlagBits::eGraphics | QueueFlagBits::eCompute | QueueFlagBits::eTransfer | static VULKAN_HPP_CONST_OR_CONSTEXPR QueueFlags allFlags = QueueFlagBits::eGraphics | QueueFlagBits::eCompute | QueueFlagBits::eTransfer |
QueueFlagBits::eSparseBinding | QueueFlagBits::eProtected | QueueFlagBits::eVideoDecodeKHR QueueFlagBits::eSparseBinding | QueueFlagBits::eProtected | QueueFlagBits::eVideoDecodeKHR
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
| QueueFlagBits::eVideoEncodeKHR | QueueFlagBits::eVideoEncodeKHR
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
| QueueFlagBits::eOpticalFlowNV; | QueueFlagBits::eOpticalFlowNV;
}; };
enum class SampleCountFlagBits : VkSampleCountFlags enum class SampleCountFlagBits : VkSampleCountFlags
@ -3989,7 +3993,7 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags = ResolveModeFlagBits::eNone | ResolveModeFlagBits::eSampleZero | static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags = ResolveModeFlagBits::eNone | ResolveModeFlagBits::eSampleZero |
ResolveModeFlagBits::eAverage | ResolveModeFlagBits::eMin | ResolveModeFlagBits::eMax ResolveModeFlagBits::eAverage | ResolveModeFlagBits::eMin | ResolveModeFlagBits::eMax
#if defined( VK_USE_PLATFORM_ANDROID_KHR ) #if defined( VK_USE_PLATFORM_ANDROID_KHR )
| ResolveModeFlagBits::eExternalFormatDownsampleANDROID | ResolveModeFlagBits::eExternalFormatDownsampleANDROID
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
; ;
}; };
@ -4797,7 +4801,7 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionCreateFlagsKHR allFlags = VideoSessionCreateFlagBitsKHR::eProtectedContent static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionCreateFlagsKHR allFlags = VideoSessionCreateFlagBitsKHR::eProtectedContent
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
| VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations | VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
; ;
}; };
@ -4819,7 +4823,7 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodingControlFlagsKHR allFlags = VideoCodingControlFlagBitsKHR::eReset static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodingControlFlagsKHR allFlags = VideoCodingControlFlagBitsKHR::eReset
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
| VideoCodingControlFlagBitsKHR::eEncodeRateControl | | VideoCodingControlFlagBitsKHR::eEncodeRateControl |
VideoCodingControlFlagBitsKHR::eEncodeQualityLevel VideoCodingControlFlagBitsKHR::eEncodeQualityLevel
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
; ;
@ -5876,16 +5880,6 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCompilerControlFlagsAMD allFlags = {}; static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCompilerControlFlagsAMD allFlags = {};
}; };
//=== VK_EXT_calibrated_timestamps ===
enum class TimeDomainEXT
{
eDevice = VK_TIME_DOMAIN_DEVICE_EXT,
eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT,
eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT,
eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT
};
//=== VK_KHR_global_priority === //=== VK_KHR_global_priority ===
enum class QueueGlobalPriorityKHR enum class QueueGlobalPriorityKHR
@ -7201,6 +7195,17 @@ namespace VULKAN_HPP_NAMESPACE
eD3D12 = VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT eD3D12 = VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT
}; };
//=== VK_KHR_calibrated_timestamps ===
enum class TimeDomainKHR
{
eDevice = VK_TIME_DOMAIN_DEVICE_KHR,
eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR,
eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR,
eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR
};
using TimeDomainEXT = TimeDomainKHR;
//========================= //=========================
//=== Index Type Traits === //=== Index Type Traits ===
//========================= //=========================

2834
include/vulkan/vulkan_extension_inspection.hpp
View file

File diff suppressed because it is too large Load diff

1
include/vulkan/vulkan_format_traits.hpp
View file

@ -12,6 +12,7 @@
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
//===================== //=====================
//=== Format Traits === //=== Format Traits ===
//===================== //=====================

184
include/vulkan/vulkan_funcs.hpp
View file

@ -10,6 +10,7 @@
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
//=========================== //===========================
//=== COMMAND Definitions === //=== COMMAND Definitions ===
//=========================== //===========================
@ -16296,22 +16297,22 @@ namespace VULKAN_HPP_NAMESPACE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount,
VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains, VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( return static_cast<Result>(
d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( pTimeDomains ) ) ); d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( pTimeDomains ) ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename TimeDomainEXTAllocator, typename Dispatch> template <typename TimeDomainKHRAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator>>::type VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator> timeDomains; std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains;
uint32_t timeDomainCount; uint32_t timeDomainCount;
VkResult result; VkResult result;
do do
@ -16321,7 +16322,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
timeDomains.resize( timeDomainCount ); timeDomains.resize( timeDomainCount );
result = result =
d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ); d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) );
} }
} while ( result == VK_INCOMPLETE ); } while ( result == VK_INCOMPLETE );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
@ -16333,16 +16334,16 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), timeDomains ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), timeDomains );
} }
template <typename TimeDomainEXTAllocator, template <typename TimeDomainKHRAllocator,
typename Dispatch, typename Dispatch,
typename B1, typename B1,
typename std::enable_if<std::is_same<typename B1::value_type, TimeDomainEXT>::value, int>::type> typename std::enable_if<std::is_same<typename B1::value_type, TimeDomainKHR>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator>>::type VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator, Dispatch const & d ) const PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT, TimeDomainEXTAllocator> timeDomains( timeDomainEXTAllocator ); std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator );
uint32_t timeDomainCount; uint32_t timeDomainCount;
VkResult result; VkResult result;
do do
@ -16352,7 +16353,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
timeDomains.resize( timeDomainCount ); timeDomains.resize( timeDomainCount );
result = result =
d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ); d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) );
} }
} while ( result == VK_INCOMPLETE ); } while ( result == VK_INCOMPLETE );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
@ -16367,20 +16368,20 @@ namespace VULKAN_HPP_NAMESPACE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount,
const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos, const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
uint64_t * pTimestamps, uint64_t * pTimestamps,
uint64_t * pMaxDeviation, uint64_t * pMaxDeviation,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkGetCalibratedTimestampsEXT( return static_cast<Result>( d.vkGetCalibratedTimestampsEXT(
m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( pTimestampInfos ), pTimestamps, pMaxDeviation ) ); m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Uint64_tAllocator, typename Dispatch> template <typename Uint64_tAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
Device::getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, Device::getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -16390,7 +16391,7 @@ namespace VULKAN_HPP_NAMESPACE
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first; std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
uint64_t & maxDeviation = data_.second; uint64_t & maxDeviation = data_.second;
VkResult result = d.vkGetCalibratedTimestampsEXT( VkResult result = d.vkGetCalibratedTimestampsEXT(
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ); m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
@ -16401,7 +16402,7 @@ namespace VULKAN_HPP_NAMESPACE
typename B0, typename B0,
typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type> typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
Device::getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, Device::getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
Uint64_tAllocator & uint64_tAllocator, Uint64_tAllocator & uint64_tAllocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
@ -16412,7 +16413,7 @@ namespace VULKAN_HPP_NAMESPACE
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first; std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
uint64_t & maxDeviation = data_.second; uint64_t & maxDeviation = data_.second;
VkResult result = d.vkGetCalibratedTimestampsEXT( VkResult result = d.vkGetCalibratedTimestampsEXT(
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ); m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
@ -16420,7 +16421,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo, Dispatch const & d ) const Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -16428,7 +16429,7 @@ namespace VULKAN_HPP_NAMESPACE
uint64_t & timestamp = data_.first; uint64_t & timestamp = data_.first;
uint64_t & maxDeviation = data_.second; uint64_t & maxDeviation = data_.second;
VkResult result = VkResult result =
d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation ); d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( &timestampInfo ), &timestamp, &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
@ -23338,5 +23339,148 @@ namespace VULKAN_HPP_NAMESPACE
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_KHR_calibrated_timestamps ===
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount,
VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>(
d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( pTimeDomains ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename TimeDomainKHRAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
PhysicalDevice::getCalibrateableTimeDomainsKHR( Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains;
uint32_t timeDomainCount;
VkResult result;
do
{
result = d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr );
if ( ( result == VK_SUCCESS ) && timeDomainCount )
{
timeDomains.resize( timeDomainCount );
result =
d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) );
}
} while ( result == VK_INCOMPLETE );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" );
VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
if ( timeDomainCount < timeDomains.size() )
{
timeDomains.resize( timeDomainCount );
}
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), timeDomains );
}
template <typename TimeDomainKHRAllocator,
typename Dispatch,
typename B1,
typename std::enable_if<std::is_same<typename B1::value_type, TimeDomainKHR>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator>>::type
PhysicalDevice::getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR, TimeDomainKHRAllocator> timeDomains( timeDomainKHRAllocator );
uint32_t timeDomainCount;
VkResult result;
do
{
result = d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr );
if ( ( result == VK_SUCCESS ) && timeDomainCount )
{
timeDomains.resize( timeDomainCount );
result =
d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) );
}
} while ( result == VK_INCOMPLETE );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" );
VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
if ( timeDomainCount < timeDomains.size() )
{
timeDomains.resize( timeDomainCount );
}
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), timeDomains );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsKHR( uint32_t timestampCount,
const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
uint64_t * pTimestamps,
uint64_t * pMaxDeviation,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkGetCalibratedTimestampsKHR(
m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Uint64_tAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
Device::getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
uint64_t & maxDeviation = data_.second;
VkResult result = d.vkGetCalibratedTimestampsKHR(
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
}
template <typename Uint64_tAllocator,
typename Dispatch,
typename B0,
typename std::enable_if<std::is_same<typename B0::value_type, uint64_t>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
Device::getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
Uint64_tAllocator & uint64_tAllocator,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) );
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
uint64_t & maxDeviation = data_.second;
VkResult result = d.vkGetCalibratedTimestampsKHR(
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), timestamps.data(), &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
}
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
Device::getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<uint64_t, uint64_t> data_;
uint64_t & timestamp = data_.first;
uint64_t & maxDeviation = data_.second;
VkResult result =
d.vkGetCalibratedTimestampsKHR( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( &timestampInfo ), &timestamp, &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
} // namespace VULKAN_HPP_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE
#endif #endif

447
include/vulkan/vulkan_handles.hpp
View file

File diff suppressed because it is too large Load diff

57
include/vulkan/vulkan_hash.hpp
View file

@ -2004,14 +2004,14 @@ namespace std
}; };
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>
{ {
std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT const & calibratedTimestampInfoEXT ) const VULKAN_HPP_NOEXCEPT std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT
{ {
std::size_t seed = 0; std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoEXT.timeDomain ); VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain );
return seed; return seed;
} }
}; };
@ -11732,16 +11732,16 @@ namespace std
}; };
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR>
{ {
std::size_t operator()( std::size_t operator()(
VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & physicalDeviceVertexAttributeDivisorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR const & physicalDeviceVertexAttributeDivisorFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{ {
std::size_t seed = 0; std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateDivisor );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateZeroDivisor ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeaturesKHR.vertexAttributeInstanceRateZeroDivisor );
return seed; return seed;
} }
}; };
@ -11760,6 +11760,21 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR const & physicalDeviceVertexAttributeDivisorPropertiesKHR )
const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.maxVertexAttribDivisor );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesKHR.supportsNonZeroFirstInstance );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT>
{ {
@ -12754,29 +12769,29 @@ namespace std
}; };
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT> struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR>
{ {
std::size_t std::size_t
operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT const & vertexInputBindingDivisorDescriptionEXT ) const VULKAN_HPP_NOEXCEPT operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR const & vertexInputBindingDivisorDescriptionKHR ) const VULKAN_HPP_NOEXCEPT
{ {
std::size_t seed = 0; std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionEXT.binding ); VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.binding );
VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionEXT.divisor ); VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescriptionKHR.divisor );
return seed; return seed;
} }
}; };
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT> struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR>
{ {
std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT const & pipelineVertexInputDivisorStateCreateInfoEXT ) const std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR const & pipelineVertexInputDivisorStateCreateInfoKHR ) const
VULKAN_HPP_NOEXCEPT VULKAN_HPP_NOEXCEPT
{ {
std::size_t seed = 0; std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.vertexBindingDivisorCount ); VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.vertexBindingDivisorCount );
VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoEXT.pVertexBindingDivisors ); VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfoKHR.pVertexBindingDivisors );
return seed; return seed;
} }
}; };

1
include/vulkan/vulkan_hpp_macros.hpp
View file

@ -248,6 +248,7 @@ namespace VULKAN_HPP_NAMESPACE
{ \ { \
VULKAN_HPP_STORAGE_API ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; \ VULKAN_HPP_STORAGE_API ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
} }
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
extern VULKAN_HPP_STORAGE_API VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; extern VULKAN_HPP_STORAGE_API VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic;

434
include/vulkan/vulkan_raii.hpp
View file

File diff suppressed because it is too large Load diff

84
include/vulkan/vulkan_shared.hpp
View file

@ -88,7 +88,8 @@ namespace VULKAN_HPP_NAMESPACE
ReferenceCounter( Args &&... control_args ) : m_header( std::forward<Args>( control_args )... ) ReferenceCounter( Args &&... control_args ) : m_header( std::forward<Args>( control_args )... )
{ {
} }
ReferenceCounter( const ReferenceCounter & ) = delete;
ReferenceCounter( const ReferenceCounter & ) = delete;
ReferenceCounter & operator=( const ReferenceCounter & ) = delete; ReferenceCounter & operator=( const ReferenceCounter & ) = delete;
public: public:
@ -427,7 +428,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = NoDestructor; using DestructorType = NoDestructor;
using deleter = ObjectDestroyShared<Instance>; using deleter = ObjectDestroyShared<Instance>;
}; };
using SharedInstance = SharedHandle<Instance>; using SharedInstance = SharedHandle<Instance>;
template <> template <>
class SharedHandleTraits<Device> class SharedHandleTraits<Device>
{ {
@ -435,7 +438,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = NoDestructor; using DestructorType = NoDestructor;
using deleter = ObjectDestroyShared<Device>; using deleter = ObjectDestroyShared<Device>;
}; };
using SharedDevice = SharedHandle<Device>; using SharedDevice = SharedHandle<Device>;
template <> template <>
class SharedHandleTraits<DeviceMemory> class SharedHandleTraits<DeviceMemory>
{ {
@ -443,7 +448,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectFreeShared<DeviceMemory>; using deleter = ObjectFreeShared<DeviceMemory>;
}; };
using SharedDeviceMemory = SharedHandle<DeviceMemory>; using SharedDeviceMemory = SharedHandle<DeviceMemory>;
template <> template <>
class SharedHandleTraits<Fence> class SharedHandleTraits<Fence>
{ {
@ -451,7 +458,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<Fence>; using deleter = ObjectDestroyShared<Fence>;
}; };
using SharedFence = SharedHandle<Fence>; using SharedFence = SharedHandle<Fence>;
template <> template <>
class SharedHandleTraits<Semaphore> class SharedHandleTraits<Semaphore>
{ {
@ -459,7 +468,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<Semaphore>; using deleter = ObjectDestroyShared<Semaphore>;
}; };
using SharedSemaphore = SharedHandle<Semaphore>; using SharedSemaphore = SharedHandle<Semaphore>;
template <> template <>
class SharedHandleTraits<Event> class SharedHandleTraits<Event>
{ {
@ -467,7 +478,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<Event>; using deleter = ObjectDestroyShared<Event>;
}; };
using SharedEvent = SharedHandle<Event>; using SharedEvent = SharedHandle<Event>;
template <> template <>
class SharedHandleTraits<QueryPool> class SharedHandleTraits<QueryPool>
{ {
@ -475,7 +488,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<QueryPool>; using deleter = ObjectDestroyShared<QueryPool>;
}; };
using SharedQueryPool = SharedHandle<QueryPool>; using SharedQueryPool = SharedHandle<QueryPool>;
template <> template <>
class SharedHandleTraits<Buffer> class SharedHandleTraits<Buffer>
{ {
@ -483,7 +498,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<Buffer>; using deleter = ObjectDestroyShared<Buffer>;
}; };
using SharedBuffer = SharedHandle<Buffer>; using SharedBuffer = SharedHandle<Buffer>;
template <> template <>
class SharedHandleTraits<BufferView> class SharedHandleTraits<BufferView>
{ {
@ -491,7 +508,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<BufferView>; using deleter = ObjectDestroyShared<BufferView>;
}; };
using SharedBufferView = SharedHandle<BufferView>; using SharedBufferView = SharedHandle<BufferView>;
template <> template <>
class SharedHandleTraits<Image> class SharedHandleTraits<Image>
{ {
@ -499,7 +518,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<Image>; using deleter = ObjectDestroyShared<Image>;
}; };
using SharedImage = SharedHandle<Image>; using SharedImage = SharedHandle<Image>;
template <> template <>
class SharedHandleTraits<ImageView> class SharedHandleTraits<ImageView>
{ {
@ -507,7 +528,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<ImageView>; using deleter = ObjectDestroyShared<ImageView>;
}; };
using SharedImageView = SharedHandle<ImageView>; using SharedImageView = SharedHandle<ImageView>;
template <> template <>
class SharedHandleTraits<ShaderModule> class SharedHandleTraits<ShaderModule>
{ {
@ -515,7 +538,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<ShaderModule>; using deleter = ObjectDestroyShared<ShaderModule>;
}; };
using SharedShaderModule = SharedHandle<ShaderModule>; using SharedShaderModule = SharedHandle<ShaderModule>;
template <> template <>
class SharedHandleTraits<PipelineCache> class SharedHandleTraits<PipelineCache>
{ {
@ -523,7 +548,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<PipelineCache>; using deleter = ObjectDestroyShared<PipelineCache>;
}; };
using SharedPipelineCache = SharedHandle<PipelineCache>; using SharedPipelineCache = SharedHandle<PipelineCache>;
template <> template <>
class SharedHandleTraits<Pipeline> class SharedHandleTraits<Pipeline>
{ {
@ -531,7 +558,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<Pipeline>; using deleter = ObjectDestroyShared<Pipeline>;
}; };
using SharedPipeline = SharedHandle<Pipeline>; using SharedPipeline = SharedHandle<Pipeline>;
template <> template <>
class SharedHandleTraits<PipelineLayout> class SharedHandleTraits<PipelineLayout>
{ {
@ -539,7 +568,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<PipelineLayout>; using deleter = ObjectDestroyShared<PipelineLayout>;
}; };
using SharedPipelineLayout = SharedHandle<PipelineLayout>; using SharedPipelineLayout = SharedHandle<PipelineLayout>;
template <> template <>
class SharedHandleTraits<Sampler> class SharedHandleTraits<Sampler>
{ {
@ -547,7 +578,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<Sampler>; using deleter = ObjectDestroyShared<Sampler>;
}; };
using SharedSampler = SharedHandle<Sampler>; using SharedSampler = SharedHandle<Sampler>;
template <> template <>
class SharedHandleTraits<DescriptorPool> class SharedHandleTraits<DescriptorPool>
{ {
@ -555,7 +588,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<DescriptorPool>; using deleter = ObjectDestroyShared<DescriptorPool>;
}; };
using SharedDescriptorPool = SharedHandle<DescriptorPool>; using SharedDescriptorPool = SharedHandle<DescriptorPool>;
template <> template <>
class SharedHandleTraits<DescriptorSet> class SharedHandleTraits<DescriptorSet>
{ {
@ -563,7 +598,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = PoolFreeShared<DescriptorSet, DescriptorPool>; using deleter = PoolFreeShared<DescriptorSet, DescriptorPool>;
}; };
using SharedDescriptorSet = SharedHandle<DescriptorSet>; using SharedDescriptorSet = SharedHandle<DescriptorSet>;
template <> template <>
class SharedHandleTraits<DescriptorSetLayout> class SharedHandleTraits<DescriptorSetLayout>
{ {
@ -571,7 +608,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<DescriptorSetLayout>; using deleter = ObjectDestroyShared<DescriptorSetLayout>;
}; };
using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>; using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
template <> template <>
class SharedHandleTraits<Framebuffer> class SharedHandleTraits<Framebuffer>
{ {
@ -579,7 +618,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<Framebuffer>; using deleter = ObjectDestroyShared<Framebuffer>;
}; };
using SharedFramebuffer = SharedHandle<Framebuffer>; using SharedFramebuffer = SharedHandle<Framebuffer>;
template <> template <>
class SharedHandleTraits<RenderPass> class SharedHandleTraits<RenderPass>
{ {
@ -587,7 +628,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<RenderPass>; using deleter = ObjectDestroyShared<RenderPass>;
}; };
using SharedRenderPass = SharedHandle<RenderPass>; using SharedRenderPass = SharedHandle<RenderPass>;
template <> template <>
class SharedHandleTraits<CommandPool> class SharedHandleTraits<CommandPool>
{ {
@ -595,7 +638,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<CommandPool>; using deleter = ObjectDestroyShared<CommandPool>;
}; };
using SharedCommandPool = SharedHandle<CommandPool>; using SharedCommandPool = SharedHandle<CommandPool>;
template <> template <>
class SharedHandleTraits<CommandBuffer> class SharedHandleTraits<CommandBuffer>
{ {
@ -603,6 +648,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = PoolFreeShared<CommandBuffer, CommandPool>; using deleter = PoolFreeShared<CommandBuffer, CommandPool>;
}; };
using SharedCommandBuffer = SharedHandle<CommandBuffer>; using SharedCommandBuffer = SharedHandle<CommandBuffer>;
//=== VK_VERSION_1_1 === //=== VK_VERSION_1_1 ===
@ -613,8 +659,10 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<SamplerYcbcrConversion>; using deleter = ObjectDestroyShared<SamplerYcbcrConversion>;
}; };
using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>; using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>; using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>;
template <> template <>
class SharedHandleTraits<DescriptorUpdateTemplate> class SharedHandleTraits<DescriptorUpdateTemplate>
{ {
@ -622,8 +670,10 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<DescriptorUpdateTemplate>; using deleter = ObjectDestroyShared<DescriptorUpdateTemplate>;
}; };
using SharedDescriptorUpdateTemplate = SharedHandle<DescriptorUpdateTemplate>; using SharedDescriptorUpdateTemplate = SharedHandle<DescriptorUpdateTemplate>;
using SharedDescriptorUpdateTemplateKHR = SharedHandle<DescriptorUpdateTemplate>; using SharedDescriptorUpdateTemplateKHR = SharedHandle<DescriptorUpdateTemplate>;
//=== VK_VERSION_1_3 === //=== VK_VERSION_1_3 ===
template <> template <>
class SharedHandleTraits<PrivateDataSlot> class SharedHandleTraits<PrivateDataSlot>
@ -632,8 +682,10 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<PrivateDataSlot>; using deleter = ObjectDestroyShared<PrivateDataSlot>;
}; };
using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>; using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>;
using SharedPrivateDataSlotEXT = SharedHandle<PrivateDataSlot>; using SharedPrivateDataSlotEXT = SharedHandle<PrivateDataSlot>;
//=== VK_KHR_surface === //=== VK_KHR_surface ===
template <> template <>
class SharedHandleTraits<SurfaceKHR> class SharedHandleTraits<SurfaceKHR>
@ -642,6 +694,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Instance; using DestructorType = Instance;
using deleter = ObjectDestroyShared<SurfaceKHR>; using deleter = ObjectDestroyShared<SurfaceKHR>;
}; };
using SharedSurfaceKHR = SharedHandle<SurfaceKHR>; using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
//=== VK_KHR_swapchain === //=== VK_KHR_swapchain ===
@ -652,6 +705,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<SwapchainKHR>; using deleter = ObjectDestroyShared<SwapchainKHR>;
}; };
using SharedSwapchainKHR = SharedHandle<SwapchainKHR>; using SharedSwapchainKHR = SharedHandle<SwapchainKHR>;
//=== VK_KHR_display === //=== VK_KHR_display ===
@ -662,6 +716,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = PhysicalDevice; using DestructorType = PhysicalDevice;
using deleter = ObjectDestroyShared<DisplayKHR>; using deleter = ObjectDestroyShared<DisplayKHR>;
}; };
using SharedDisplayKHR = SharedHandle<DisplayKHR>; using SharedDisplayKHR = SharedHandle<DisplayKHR>;
//=== VK_EXT_debug_report === //=== VK_EXT_debug_report ===
@ -672,6 +727,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Instance; using DestructorType = Instance;
using deleter = ObjectDestroyShared<DebugReportCallbackEXT>; using deleter = ObjectDestroyShared<DebugReportCallbackEXT>;
}; };
using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>; using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>;
//=== VK_KHR_video_queue === //=== VK_KHR_video_queue ===
@ -682,7 +738,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<VideoSessionKHR>; using deleter = ObjectDestroyShared<VideoSessionKHR>;
}; };
using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>; using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>;
template <> template <>
class SharedHandleTraits<VideoSessionParametersKHR> class SharedHandleTraits<VideoSessionParametersKHR>
{ {
@ -690,6 +748,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<VideoSessionParametersKHR>; using deleter = ObjectDestroyShared<VideoSessionParametersKHR>;
}; };
using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>; using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>;
//=== VK_NVX_binary_import === //=== VK_NVX_binary_import ===
@ -700,7 +759,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<CuModuleNVX>; using deleter = ObjectDestroyShared<CuModuleNVX>;
}; };
using SharedCuModuleNVX = SharedHandle<CuModuleNVX>; using SharedCuModuleNVX = SharedHandle<CuModuleNVX>;
template <> template <>
class SharedHandleTraits<CuFunctionNVX> class SharedHandleTraits<CuFunctionNVX>
{ {
@ -708,6 +769,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<CuFunctionNVX>; using deleter = ObjectDestroyShared<CuFunctionNVX>;
}; };
using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>; using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>;
//=== VK_EXT_debug_utils === //=== VK_EXT_debug_utils ===
@ -718,6 +780,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Instance; using DestructorType = Instance;
using deleter = ObjectDestroyShared<DebugUtilsMessengerEXT>; using deleter = ObjectDestroyShared<DebugUtilsMessengerEXT>;
}; };
using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>; using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
//=== VK_KHR_acceleration_structure === //=== VK_KHR_acceleration_structure ===
@ -728,6 +791,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<AccelerationStructureKHR>; using deleter = ObjectDestroyShared<AccelerationStructureKHR>;
}; };
using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>; using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>;
//=== VK_EXT_validation_cache === //=== VK_EXT_validation_cache ===
@ -738,6 +802,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<ValidationCacheEXT>; using deleter = ObjectDestroyShared<ValidationCacheEXT>;
}; };
using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>; using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>;
//=== VK_NV_ray_tracing === //=== VK_NV_ray_tracing ===
@ -748,6 +813,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<AccelerationStructureNV>; using deleter = ObjectDestroyShared<AccelerationStructureNV>;
}; };
using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>; using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>;
//=== VK_INTEL_performance_query === //=== VK_INTEL_performance_query ===
@ -758,6 +824,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<PerformanceConfigurationINTEL>; using deleter = ObjectDestroyShared<PerformanceConfigurationINTEL>;
}; };
using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>; using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>;
//=== VK_KHR_deferred_host_operations === //=== VK_KHR_deferred_host_operations ===
@ -768,6 +835,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<DeferredOperationKHR>; using deleter = ObjectDestroyShared<DeferredOperationKHR>;
}; };
using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>; using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>;
//=== VK_NV_device_generated_commands === //=== VK_NV_device_generated_commands ===
@ -778,6 +846,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<IndirectCommandsLayoutNV>; using deleter = ObjectDestroyShared<IndirectCommandsLayoutNV>;
}; };
using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>; using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>;
# if defined( VK_ENABLE_BETA_EXTENSIONS ) # if defined( VK_ENABLE_BETA_EXTENSIONS )
@ -789,7 +858,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<CudaModuleNV>; using deleter = ObjectDestroyShared<CudaModuleNV>;
}; };
using SharedCudaModuleNV = SharedHandle<CudaModuleNV>; using SharedCudaModuleNV = SharedHandle<CudaModuleNV>;
template <> template <>
class SharedHandleTraits<CudaFunctionNV> class SharedHandleTraits<CudaFunctionNV>
{ {
@ -797,6 +868,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<CudaFunctionNV>; using deleter = ObjectDestroyShared<CudaFunctionNV>;
}; };
using SharedCudaFunctionNV = SharedHandle<CudaFunctionNV>; using SharedCudaFunctionNV = SharedHandle<CudaFunctionNV>;
# endif /*VK_ENABLE_BETA_EXTENSIONS*/ # endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -809,6 +881,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<BufferCollectionFUCHSIA>; using deleter = ObjectDestroyShared<BufferCollectionFUCHSIA>;
}; };
using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>; using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>;
# endif /*VK_USE_PLATFORM_FUCHSIA*/ # endif /*VK_USE_PLATFORM_FUCHSIA*/
@ -820,6 +893,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<MicromapEXT>; using deleter = ObjectDestroyShared<MicromapEXT>;
}; };
using SharedMicromapEXT = SharedHandle<MicromapEXT>; using SharedMicromapEXT = SharedHandle<MicromapEXT>;
//=== VK_NV_optical_flow === //=== VK_NV_optical_flow ===
@ -830,6 +904,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<OpticalFlowSessionNV>; using deleter = ObjectDestroyShared<OpticalFlowSessionNV>;
}; };
using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>; using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>;
//=== VK_EXT_shader_object === //=== VK_EXT_shader_object ===
@ -840,6 +915,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = ObjectDestroyShared<ShaderEXT>; using deleter = ObjectDestroyShared<ShaderEXT>;
}; };
using SharedShaderEXT = SharedHandle<ShaderEXT>; using SharedShaderEXT = SharedHandle<ShaderEXT>;
enum class SwapchainOwns enum class SwapchainOwns
@ -960,11 +1036,13 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
SharedHandle() = default; SharedHandle() = default;
explicit SharedHandle( PhysicalDevice handle, SharedInstance parent ) noexcept explicit SharedHandle( PhysicalDevice handle, SharedInstance parent ) noexcept
: SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>( handle, std::move( parent ) ) : SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>( handle, std::move( parent ) )
{ {
} }
}; };
using SharedPhysicalDevice = SharedHandle<PhysicalDevice>; using SharedPhysicalDevice = SharedHandle<PhysicalDevice>;
template <> template <>
@ -974,8 +1052,10 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
SharedHandle() = default; SharedHandle() = default;
explicit SharedHandle( Queue handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy<Queue, SharedDevice>( handle, std::move( parent ) ) {} explicit SharedHandle( Queue handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy<Queue, SharedDevice>( handle, std::move( parent ) ) {}
}; };
using SharedQueue = SharedHandle<Queue>; using SharedQueue = SharedHandle<Queue>;
//=== VK_KHR_display === //=== VK_KHR_display ===
@ -987,11 +1067,13 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
SharedHandle() = default; SharedHandle() = default;
explicit SharedHandle( DisplayModeKHR handle, SharedDisplayKHR parent ) noexcept explicit SharedHandle( DisplayModeKHR handle, SharedDisplayKHR parent ) noexcept
: SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>( handle, std::move( parent ) ) : SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>( handle, std::move( parent ) )
{ {
} }
}; };
using SharedDisplayModeKHR = SharedHandle<DisplayModeKHR>; using SharedDisplayModeKHR = SharedHandle<DisplayModeKHR>;
#endif // !VULKAN_HPP_NO_SMART_HANDLE #endif // !VULKAN_HPP_NO_SMART_HANDLE
} // namespace VULKAN_HPP_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE

72
include/vulkan/vulkan_static_assertions.hpp
View file

@ -3913,14 +3913,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Pipeline
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD>::value,
"PipelineCompilerControlCreateInfoAMD is not nothrow_move_constructible!" ); "PipelineCompilerControlCreateInfoAMD is not nothrow_move_constructible!" );
//=== VK_EXT_calibrated_timestamps ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT>::value,
"CalibratedTimestampInfoEXT is not nothrow_move_constructible!" );
//=== VK_AMD_shader_core_properties === //=== VK_AMD_shader_core_properties ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ),
@ -4014,29 +4006,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>::value,
"PhysicalDeviceVertexAttributeDivisorPropertiesEXT is not nothrow_move_constructible!" ); "PhysicalDeviceVertexAttributeDivisorPropertiesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>::value,
"VertexInputBindingDivisorDescriptionEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT ) ==
sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT>::value,
"PipelineVertexInputDivisorStateCreateInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) ==
sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT>::value,
"PhysicalDeviceVertexAttributeDivisorFeaturesEXT is not nothrow_move_constructible!" );
#if defined( VK_USE_PLATFORM_GGP ) #if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_frame_token === //=== VK_GGP_frame_token ===
@ -7203,6 +7172,39 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>::value,
"PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT is not nothrow_move_constructible!" ); "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT is not nothrow_move_constructible!" );
//=== VK_KHR_vertex_attribute_divisor ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR ) ==
sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR>::value,
"PhysicalDeviceVertexAttributeDivisorPropertiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR ) == sizeof( VkVertexInputBindingDivisorDescriptionKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR>::value,
"VertexInputBindingDivisorDescriptionKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR ) ==
sizeof( VkPipelineVertexInputDivisorStateCreateInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR>::value,
"PipelineVertexInputDivisorStateCreateInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR ) ==
sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR>::value,
"PhysicalDeviceVertexAttributeDivisorFeaturesKHR is not nothrow_move_constructible!" );
#if defined( VK_USE_PLATFORM_SCREEN_QNX ) #if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer === //=== VK_QNX_external_memory_screen_buffer ===
@ -7247,6 +7249,14 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>::value,
"PhysicalDeviceLayeredDriverPropertiesMSFT is not nothrow_move_constructible!" ); "PhysicalDeviceLayeredDriverPropertiesMSFT is not nothrow_move_constructible!" );
//=== VK_KHR_calibrated_timestamps ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR ) == sizeof( VkCalibratedTimestampInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR>::value,
"CalibratedTimestampInfoKHR is not nothrow_move_constructible!" );
//=== VK_NV_descriptor_pool_overallocation === //=== VK_NV_descriptor_pool_overallocation ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV ) == VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV ) ==

1854
include/vulkan/vulkan_structs.hpp
View file

File diff suppressed because it is too large Load diff

36
include/vulkan/vulkan_to_string.hpp
View file

@ -18,6 +18,7 @@
namespace VULKAN_HPP_NAMESPACE namespace VULKAN_HPP_NAMESPACE
{ {
//========================== //==========================
//=== BITMASKs to_string === //=== BITMASKs to_string ===
//========================== //==========================
@ -4099,7 +4100,6 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT"; case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
case StructureType::ePhysicalDeviceShaderClockFeaturesKHR: return "PhysicalDeviceShaderClockFeaturesKHR"; case StructureType::ePhysicalDeviceShaderClockFeaturesKHR: return "PhysicalDeviceShaderClockFeaturesKHR";
case StructureType::ePipelineCompilerControlCreateInfoAMD: return "PipelineCompilerControlCreateInfoAMD"; case StructureType::ePipelineCompilerControlCreateInfoAMD: return "PipelineCompilerControlCreateInfoAMD";
case StructureType::eCalibratedTimestampInfoEXT: return "CalibratedTimestampInfoEXT";
case StructureType::ePhysicalDeviceShaderCorePropertiesAMD: return "PhysicalDeviceShaderCorePropertiesAMD"; case StructureType::ePhysicalDeviceShaderCorePropertiesAMD: return "PhysicalDeviceShaderCorePropertiesAMD";
case StructureType::eVideoDecodeH265CapabilitiesKHR: return "VideoDecodeH265CapabilitiesKHR"; case StructureType::eVideoDecodeH265CapabilitiesKHR: return "VideoDecodeH265CapabilitiesKHR";
case StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR: return "VideoDecodeH265SessionParametersCreateInfoKHR"; case StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR: return "VideoDecodeH265SessionParametersCreateInfoKHR";
@ -4112,8 +4112,6 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eQueueFamilyGlobalPriorityPropertiesKHR: return "QueueFamilyGlobalPriorityPropertiesKHR"; case StructureType::eQueueFamilyGlobalPriorityPropertiesKHR: return "QueueFamilyGlobalPriorityPropertiesKHR";
case StructureType::eDeviceMemoryOverallocationCreateInfoAMD: return "DeviceMemoryOverallocationCreateInfoAMD"; case StructureType::eDeviceMemoryOverallocationCreateInfoAMD: return "DeviceMemoryOverallocationCreateInfoAMD";
case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT"; case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT: return "PipelineVertexInputDivisorStateCreateInfoEXT";
case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT: return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT";
#if defined( VK_USE_PLATFORM_GGP ) #if defined( VK_USE_PLATFORM_GGP )
case StructureType::ePresentFrameTokenGGP: return "PresentFrameTokenGGP"; case StructureType::ePresentFrameTokenGGP: return "PresentFrameTokenGGP";
#endif /*VK_USE_PLATFORM_GGP*/ #endif /*VK_USE_PLATFORM_GGP*/
@ -4514,6 +4512,9 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM: return "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM"; case StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM: return "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM";
case StructureType::ePhysicalDeviceCubicClampFeaturesQCOM: return "PhysicalDeviceCubicClampFeaturesQCOM"; case StructureType::ePhysicalDeviceCubicClampFeaturesQCOM: return "PhysicalDeviceCubicClampFeaturesQCOM";
case StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT: return "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT"; case StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT: return "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT";
case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesKHR: return "PhysicalDeviceVertexAttributeDivisorPropertiesKHR";
case StructureType::ePipelineVertexInputDivisorStateCreateInfoKHR: return "PipelineVertexInputDivisorStateCreateInfoKHR";
case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesKHR: return "PhysicalDeviceVertexAttributeDivisorFeaturesKHR";
#if defined( VK_USE_PLATFORM_SCREEN_QNX ) #if defined( VK_USE_PLATFORM_SCREEN_QNX )
case StructureType::eScreenBufferPropertiesQNX: return "ScreenBufferPropertiesQNX"; case StructureType::eScreenBufferPropertiesQNX: return "ScreenBufferPropertiesQNX";
case StructureType::eScreenBufferFormatPropertiesQNX: return "ScreenBufferFormatPropertiesQNX"; case StructureType::eScreenBufferFormatPropertiesQNX: return "ScreenBufferFormatPropertiesQNX";
@ -4522,6 +4523,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX"; case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT: return "PhysicalDeviceLayeredDriverPropertiesMSFT"; case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT: return "PhysicalDeviceLayeredDriverPropertiesMSFT";
case StructureType::eCalibratedTimestampInfoKHR: return "CalibratedTimestampInfoKHR";
case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV"; case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
@ -7894,20 +7896,6 @@ namespace VULKAN_HPP_NAMESPACE
return "(void)"; return "(void)";
} }
//=== VK_EXT_calibrated_timestamps ===
VULKAN_HPP_INLINE std::string to_string( TimeDomainEXT value )
{
switch ( value )
{
case TimeDomainEXT::eDevice: return "Device";
case TimeDomainEXT::eClockMonotonic: return "ClockMonotonic";
case TimeDomainEXT::eClockMonotonicRaw: return "ClockMonotonicRaw";
case TimeDomainEXT::eQueryPerformanceCounter: return "QueryPerformanceCounter";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
//=== VK_KHR_global_priority === //=== VK_KHR_global_priority ===
VULKAN_HPP_INLINE std::string to_string( QueueGlobalPriorityKHR value ) VULKAN_HPP_INLINE std::string to_string( QueueGlobalPriorityKHR value )
@ -9060,5 +9048,19 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
//=== VK_KHR_calibrated_timestamps ===
VULKAN_HPP_INLINE std::string to_string( TimeDomainKHR value )
{
switch ( value )
{
case TimeDomainKHR::eDevice: return "Device";
case TimeDomainKHR::eClockMonotonic: return "ClockMonotonic";
case TimeDomainKHR::eClockMonotonicRaw: return "ClockMonotonicRaw";
case TimeDomainKHR::eQueryPerformanceCounter: return "QueryPerformanceCounter";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
} // namespace VULKAN_HPP_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE
#endif #endif

187
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

103
registry/vk.xml
View file

@ -175,7 +175,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> #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 <type api="vulkan" category="define">// Version of this file
#define <name>VK_HEADER_VERSION</name> 272</type> #define <name>VK_HEADER_VERSION</name> 273</type>
<type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file <type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file
#define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 3, VK_HEADER_VERSION)</type> #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 3, VK_HEADER_VERSION)</type>
<type api="vulkansc" category="define">// Version of this file <type api="vulkansc" category="define">// Version of this file
@ -686,7 +686,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkShaderInfoTypeAMD" category="enum"/> <type name="VkShaderInfoTypeAMD" category="enum"/>
<type name="VkQueueGlobalPriorityKHR" category="enum"/> <type name="VkQueueGlobalPriorityKHR" category="enum"/>
<type name="VkQueueGlobalPriorityEXT" category="enum" alias="VkQueueGlobalPriorityKHR"/> <type name="VkQueueGlobalPriorityEXT" category="enum" alias="VkQueueGlobalPriorityKHR"/>
<type name="VkTimeDomainEXT" category="enum"/> <type name="VkTimeDomainKHR" category="enum"/>
<type name="VkTimeDomainEXT" category="enum" alias="VkTimeDomainKHR"/>
<type name="VkConservativeRasterizationModeEXT" category="enum"/> <type name="VkConservativeRasterizationModeEXT" category="enum"/>
<type name="VkResolveModeFlagBits" category="enum"/> <type name="VkResolveModeFlagBits" category="enum"/>
<type category="enum" name="VkResolveModeFlagBitsKHR" alias="VkResolveModeFlagBits"/> <type category="enum" name="VkResolveModeFlagBitsKHR" alias="VkResolveModeFlagBits"/>
@ -3929,11 +3930,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="bitmask"><type>VkBool32</type> <name>fullyCoveredFragmentShaderInputVariable</name><comment>true if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable</comment></member> <member limittype="bitmask"><type>VkBool32</type> <name>fullyCoveredFragmentShaderInputVariable</name><comment>true if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable</comment></member>
<member limittype="bitmask"><type>VkBool32</type> <name>conservativeRasterizationPostDepthCoverage</name><comment>true if the implementation supports both conservative rasterization and post depth coverage sample coverage mask</comment></member> <member limittype="bitmask"><type>VkBool32</type> <name>conservativeRasterizationPostDepthCoverage</name><comment>true if the implementation supports both conservative rasterization and post depth coverage sample coverage mask</comment></member>
</type> </type>
<type category="struct" name="VkCalibratedTimestampInfoEXT"> <type category="struct" name="VkCalibratedTimestampInfoKHR">
<member values="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member> <member values="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_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>void</type>* <name>pNext</name></member>
<member><type>VkTimeDomainEXT</type> <name>timeDomain</name></member> <member><type>VkTimeDomainKHR</type> <name>timeDomain</name></member>
</type> </type>
<type category="struct" name="VkCalibratedTimestampInfoEXT" alias="VkCalibratedTimestampInfoKHR"/>
<type category="struct" name="VkPhysicalDeviceShaderCorePropertiesAMD" returnedonly="true" structextends="VkPhysicalDeviceProperties2"> <type category="struct" name="VkPhysicalDeviceShaderCorePropertiesAMD" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"><type>VkStructureType</type> <name>sType</name></member> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member> <member optional="true"><type>void</type>* <name>pNext</name></member>
@ -4158,21 +4160,29 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>uint64_t</type> <name>value</name></member> <member><type>uint64_t</type> <name>value</name></member>
</type> </type>
<type category="struct" name="VkSemaphoreSignalInfoKHR" alias="VkSemaphoreSignalInfo"/> <type category="struct" name="VkSemaphoreSignalInfoKHR" alias="VkSemaphoreSignalInfo"/>
<type category="struct" name="VkVertexInputBindingDivisorDescriptionEXT"> <type category="struct" name="VkVertexInputBindingDivisorDescriptionKHR">
<member><type>uint32_t</type> <name>binding</name></member> <member><type>uint32_t</type> <name>binding</name></member>
<member><type>uint32_t</type> <name>divisor</name></member> <member><type>uint32_t</type> <name>divisor</name></member>
</type> </type>
<type category="struct" name="VkPipelineVertexInputDivisorStateCreateInfoEXT" structextends="VkPipelineVertexInputStateCreateInfo"> <type category="struct" name="VkVertexInputBindingDivisorDescriptionEXT" alias="VkVertexInputBindingDivisorDescriptionKHR"/>
<member values="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member> <type category="struct" name="VkPipelineVertexInputDivisorStateCreateInfoKHR" structextends="VkPipelineVertexInputStateCreateInfo">
<member values="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_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>void</type>* <name>pNext</name></member>
<member><type>uint32_t</type> <name>vertexBindingDivisorCount</name></member> <member><type>uint32_t</type> <name>vertexBindingDivisorCount</name></member>
<member len="vertexBindingDivisorCount">const <type>VkVertexInputBindingDivisorDescriptionEXT</type>* <name>pVertexBindingDivisors</name></member> <member len="vertexBindingDivisorCount">const <type>VkVertexInputBindingDivisorDescriptionKHR</type>* <name>pVertexBindingDivisors</name></member>
</type> </type>
<type category="struct" name="VkPipelineVertexInputDivisorStateCreateInfoEXT" alias="VkPipelineVertexInputDivisorStateCreateInfoKHR"/>
<type category="struct" name="VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2"> <type category="struct" name="VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member> <member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxVertexAttribDivisor</name><comment>max value of vertex attribute divisor</comment></member> <member limittype="max"><type>uint32_t</type> <name>maxVertexAttribDivisor</name><comment>max value of vertex attribute divisor</comment></member>
</type> </type>
<type category="struct" name="VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxVertexAttribDivisor</name><comment>max value of vertex attribute divisor</comment></member>
<member limittype="max"><type>VkBool32</type> <name>supportsNonZeroFirstInstance</name></member>
</type>
<type category="struct" name="VkPhysicalDevicePCIBusInfoPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true"> <type category="struct" name="VkPhysicalDevicePCIBusInfoPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member> <member optional="true"><type>void</type>* <name>pNext</name></member>
@ -4285,12 +4295,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkBool32</type> <name>shaderImageFloat32AtomicMinMax</name></member> <member><type>VkBool32</type> <name>shaderImageFloat32AtomicMinMax</name></member>
<member><type>VkBool32</type> <name>sparseImageFloat32AtomicMinMax</name></member> <member><type>VkBool32</type> <name>sparseImageFloat32AtomicMinMax</name></member>
</type> </type>
<type category="struct" name="VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo"> <type category="struct" name="VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member> <member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>vertexAttributeInstanceRateDivisor</name></member> <member><type>VkBool32</type> <name>vertexAttributeInstanceRateDivisor</name></member>
<member><type>VkBool32</type> <name>vertexAttributeInstanceRateZeroDivisor</name></member> <member><type>VkBool32</type> <name>vertexAttributeInstanceRateZeroDivisor</name></member>
</type> </type>
<type category="struct" name="VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT" alias="VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR"/>
<type category="struct" name="VkQueueFamilyCheckpointPropertiesNV" structextends="VkQueueFamilyProperties2" returnedonly="true"> <type category="struct" name="VkQueueFamilyCheckpointPropertiesNV" structextends="VkQueueFamilyProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member> <member values="VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member> <member optional="true"><type>void</type>* <name>pNext</name></member>
@ -9760,11 +9771,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enums name="VkSwapchainImageUsageFlagBitsANDROID" type="bitmask"> <enums name="VkSwapchainImageUsageFlagBitsANDROID" type="bitmask">
<enum bitpos="0" name="VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID"/> <enum bitpos="0" name="VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID"/>
</enums> </enums>
<enums name="VkTimeDomainEXT" type="enum"> <enums name="VkTimeDomainKHR" type="enum">
<enum value="0" name="VK_TIME_DOMAIN_DEVICE_EXT"/> <enum value="0" name="VK_TIME_DOMAIN_DEVICE_KHR"/>
<enum value="1" name="VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT"/> <enum value="1" name="VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR"/>
<enum value="2" name="VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT"/> <enum value="2" name="VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR"/>
<enum value="3" name="VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT"/> <enum value="3" name="VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR"/>
</enums> </enums>
<enums name="VkDebugReportFlagBitsEXT" type="bitmask"> <enums name="VkDebugReportFlagBitsEXT" type="bitmask">
<enum bitpos="0" name="VK_DEBUG_REPORT_INFORMATION_BIT_EXT"/> <enum bitpos="0" name="VK_DEBUG_REPORT_INFORMATION_BIT_EXT"/>
@ -10557,7 +10568,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="1" name="VK_PRESENT_GRAVITY_MAX_BIT_EXT"/> <enum bitpos="1" name="VK_PRESENT_GRAVITY_MAX_BIT_EXT"/>
<enum bitpos="2" name="VK_PRESENT_GRAVITY_CENTERED_BIT_EXT"/> <enum bitpos="2" name="VK_PRESENT_GRAVITY_CENTERED_BIT_EXT"/>
</enums> </enums>
<enums name="VkPhysicalDeviceSchedulingControlsFlagBitsARM" type="bitmask"> <enums name="VkPhysicalDeviceSchedulingControlsFlagBitsARM" type="bitmask" bitwidth="64">
<enum bitpos="0" name="VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM"/> <enum bitpos="0" name="VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM"/>
</enums> </enums>
@ -13104,8 +13115,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<param><type>VkDevice</type> <name>device</name></param> <param><type>VkDevice</type> <name>device</name></param>
<param><type>VkImage</type> <name>image</name></param> <param><type>VkImage</type> <name>image</name></param>
<param><type>int</type> <name>nativeFenceFd</name></param> <param><type>int</type> <name>nativeFenceFd</name></param>
<param><type>VkSemaphore</type> <name>semaphore</name></param> <param optional="true"><type>VkSemaphore</type> <name>semaphore</name></param>
<param><type>VkFence</type> <name>fence</name></param> <param optional="true"><type>VkFence</type> <name>fence</name></param>
</command> </command>
<command> <command>
<proto><type>VkResult</type> <name>vkQueueSignalReleaseImageANDROID</name></proto> <proto><type>VkResult</type> <name>vkQueueSignalReleaseImageANDROID</name></proto>
@ -13131,19 +13142,21 @@ typedef void* <name>MTLSharedEvent_id</name>;
<param><type>VkBool32</type> <name>localDimmingEnable</name></param> <param><type>VkBool32</type> <name>localDimmingEnable</name></param>
</command> </command>
<command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY"> <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
<proto><type>VkResult</type> <name>vkGetPhysicalDeviceCalibrateableTimeDomainsEXT</name></proto> <proto><type>VkResult</type> <name>vkGetPhysicalDeviceCalibrateableTimeDomainsKHR</name></proto>
<param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
<param optional="false,true"><type>uint32_t</type>* <name>pTimeDomainCount</name></param> <param optional="false,true"><type>uint32_t</type>* <name>pTimeDomainCount</name></param>
<param optional="true" len="pTimeDomainCount"><type>VkTimeDomainEXT</type>* <name>pTimeDomains</name></param> <param optional="true" len="pTimeDomainCount"><type>VkTimeDomainKHR</type>* <name>pTimeDomains</name></param>
</command> </command>
<command name="vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" alias="vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"/>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY"> <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
<proto><type>VkResult</type> <name>vkGetCalibratedTimestampsEXT</name></proto> <proto><type>VkResult</type> <name>vkGetCalibratedTimestampsKHR</name></proto>
<param><type>VkDevice</type> <name>device</name></param> <param><type>VkDevice</type> <name>device</name></param>
<param><type>uint32_t</type> <name>timestampCount</name></param> <param><type>uint32_t</type> <name>timestampCount</name></param>
<param len="timestampCount">const <type>VkCalibratedTimestampInfoEXT</type>* <name>pTimestampInfos</name></param> <param len="timestampCount">const <type>VkCalibratedTimestampInfoKHR</type>* <name>pTimestampInfos</name></param>
<param len="timestampCount"><type>uint64_t</type>* <name>pTimestamps</name></param> <param len="timestampCount"><type>uint64_t</type>* <name>pTimestamps</name></param>
<param><type>uint64_t</type>* <name>pMaxDeviation</name></param> <param><type>uint64_t</type>* <name>pMaxDeviation</name></param>
</command> </command>
<command name="vkGetCalibratedTimestampsEXT" alias="vkGetCalibratedTimestampsKHR"/>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY"> <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
<proto><type>VkResult</type> <name>vkSetDebugUtilsObjectNameEXT</name></proto> <proto><type>VkResult</type> <name>vkSetDebugUtilsObjectNameEXT</name></proto>
<param><type>VkDevice</type> <name>device</name></param> <param><type>VkDevice</type> <name>device</name></param>
@ -19347,11 +19360,15 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkPipelineCompilerControlCreateInfoAMD"/> <type name="VkPipelineCompilerControlCreateInfoAMD"/>
</require> </require>
</extension> </extension>
<extension name="VK_EXT_calibrated_timestamps" number="185" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Daniel Rakos @drakos-amd" supported="vulkan,vulkansc"> <extension name="VK_EXT_calibrated_timestamps" number="185" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Daniel Rakos @drakos-amd" promotedto="VK_KHR_calibrated_timestamps" supported="vulkan,vulkansc">
<require> <require>
<enum value="2" name="VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION"/> <enum value="2" name="VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_calibrated_timestamps&quot;" name="VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME"/> <enum value="&quot;VK_EXT_calibrated_timestamps&quot;" name="VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"/> <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT" alias="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR"/>
<enum extends="VkTimeDomainKHR" name="VK_TIME_DOMAIN_DEVICE_EXT" alias="VK_TIME_DOMAIN_DEVICE_KHR"/>
<enum extends="VkTimeDomainKHR" name="VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT" alias="VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR"/>
<enum extends="VkTimeDomainKHR" name="VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT" alias="VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR"/>
<enum extends="VkTimeDomainKHR" name="VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT" alias="VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR"/>
<type name="VkTimeDomainEXT"/> <type name="VkTimeDomainEXT"/>
<type name="VkCalibratedTimestampInfoEXT"/> <type name="VkCalibratedTimestampInfoEXT"/>
<command name="vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"/> <command name="vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"/>
@ -19417,13 +19434,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkDeviceMemoryOverallocationCreateInfoAMD"/> <type name="VkDeviceMemoryOverallocationCreateInfoAMD"/>
</require> </require>
</extension> </extension>
<extension name="VK_EXT_vertex_attribute_divisor" number="191" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Vikram Kushwaha @vkushwaha" supported="vulkan,vulkansc"> <extension name="VK_EXT_vertex_attribute_divisor" number="191" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Vikram Kushwaha @vkushwaha" supported="vulkan,vulkansc" promotedto="VK_KHR_vertex_attribute_divisor">
<require> <require>
<enum value="3" name="VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION"/> <enum value="3" name="VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_vertex_attribute_divisor&quot;" name="VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME"/> <enum value="&quot;VK_EXT_vertex_attribute_divisor&quot;" name="VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"/> <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"/> <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT" alias="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"/> <enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR"/>
<type name="VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT"/> <type name="VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT"/>
<type name="VkVertexInputBindingDivisorDescriptionEXT"/> <type name="VkVertexInputBindingDivisorDescriptionEXT"/>
<type name="VkPipelineVertexInputDivisorStateCreateInfoEXT"/> <type name="VkPipelineVertexInputDivisorStateCreateInfoEXT"/>
@ -23593,10 +23610,17 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkCmdSetAttachmentFeedbackLoopEnableEXT"/> <command name="vkCmdSetAttachmentFeedbackLoopEnableEXT"/>
</require> </require>
</extension> </extension>
<extension name="VK_EXT_extension_526" number="526" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled"> <extension name="VK_KHR_vertex_attribute_divisor" number="526" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="KHR" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan">
<require> <require>
<enum value="0" name="VK_EXT_EXTENSION_526_SPEC_VERSION"/> <enum value="1" name="VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_526&quot;" name="VK_EXT_EXTENSION_526_EXTENSION_NAME"/> <enum value="&quot;VK_KHR_vertex_attribute_divisor&quot;" name="VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR"/>
<enum offset="1" extends="VkStructureType" extnumber="191" name="VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR"/>
<enum offset="2" extends="VkStructureType" extnumber="191" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR"/>
<type name="VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR"/>
<type name="VkVertexInputBindingDivisorDescriptionKHR"/>
<type name="VkPipelineVertexInputDivisorStateCreateInfoKHR"/>
<type name="VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR"/>
</require> </require>
</extension> </extension>
<extension name="VK_EXT_extension_527" number="527" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled"> <extension name="VK_EXT_extension_527" number="527" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
@ -23716,10 +23740,15 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_543&quot;" name="VK_EXT_EXTENSION_543_EXTENSION_NAME"/> <enum value="&quot;VK_EXT_extension_543&quot;" name="VK_EXT_EXTENSION_543_EXTENSION_NAME"/>
</require> </require>
</extension> </extension>
<extension name="VK_KHR_extension_544" number="544" author="KHR" contact="Daniel Rakos @aqnuep" supported="disabled"> <extension name="VK_KHR_calibrated_timestamps" number="544" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="KHR" contact="Daniel Rakos @aqnuep" supported="vulkan" ratified="vulkan">
<require> <require>
<enum value="0" name="VK_KHR_EXTENSION_544_SPEC_VERSION"/> <enum value="1" name="VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_extension_544&quot;" name="VK_KHR_EXTENSION_544_EXTENSION_NAME"/> <enum value="&quot;VK_KHR_calibrated_timestamps&quot;" name="VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" extnumber="185" name="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR"/>
<type name="VkTimeDomainKHR"/>
<type name="VkCalibratedTimestampInfoKHR"/>
<command name="vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"/>
<command name="vkGetCalibratedTimestampsKHR"/>
</require> </require>
</extension> </extension>
<extension name="VK_KHR_extension_545" number="545" author="KHR" contact="Kevin Petit @kpet" supported="disabled"> <extension name="VK_KHR_extension_545" number="545" author="KHR" contact="Kevin Petit @kpet" supported="disabled">