diff options
| -rw-r--r-- | include/vulkan/vulkan.h | 1013 | ||||
| -rw-r--r-- | src/vulkan/registry/vk.xml | 1150 |
2 files changed, 2030 insertions, 133 deletions
diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 81dedf7773e..9407d9102aa 100644 --- a/include/vulkan/vulkan.h +++ b/include/vulkan/vulkan.h @@ -43,7 +43,7 @@ extern "C" { #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) // Version of this file -#define VK_HEADER_VERSION 39 +#define VK_HEADER_VERSION 42 #define VK_NULL_HANDLE 0 @@ -146,6 +146,7 @@ typedef enum VkResult { VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, VK_ERROR_INVALID_SHADER_NV = -1000012000, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX = -1000072003, VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, VK_RESULT_END_RANGE = VK_INCOMPLETE, VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), @@ -221,6 +222,9 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, @@ -235,19 +239,67 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006, VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = 1000060000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX = 1000060001, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX = 1000060002, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = 1000060006, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012, VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX = 1000071004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX = 1000071005, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX = 1000071006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX = 1000071007, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX = 1000072002, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX = 1000073002, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX = 1000074001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX = 1000075000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX = 1000076001, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX = 1000077000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000, VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = 1000090000, VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), @@ -716,6 +768,8 @@ typedef enum VkDynamicState { VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), @@ -881,6 +935,7 @@ typedef enum VkImageCreateFlagBits { VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, + VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040, VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020, VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkImageCreateFlagBits; @@ -919,6 +974,7 @@ typedef VkFlags VkMemoryPropertyFlags; typedef enum VkMemoryHeapFlagBits { VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002, VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkMemoryHeapFlagBits; typedef VkFlags VkMemoryHeapFlags; @@ -1036,6 +1092,8 @@ typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008, + VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010, VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkPipelineCreateFlagBits; typedef VkFlags VkPipelineCreateFlags; @@ -1082,6 +1140,11 @@ typedef VkFlags VkPipelineDynamicStateCreateFlags; typedef VkFlags VkPipelineLayoutCreateFlags; typedef VkFlags VkShaderStageFlags; typedef VkFlags VkSamplerCreateFlags; + +typedef enum VkDescriptorSetLayoutCreateFlagBits { + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetLayoutCreateFlagBits; typedef VkFlags VkDescriptorSetLayoutCreateFlags; typedef enum VkDescriptorPoolCreateFlagBits { @@ -1098,6 +1161,12 @@ typedef enum VkAttachmentDescriptionFlagBits { VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkAttachmentDescriptionFlagBits; typedef VkFlags VkAttachmentDescriptionFlags; + +typedef enum VkSubpassDescriptionFlagBits { + VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, + VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, + VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassDescriptionFlagBits; typedef VkFlags VkSubpassDescriptionFlags; typedef enum VkAccessFlagBits { @@ -1126,6 +1195,8 @@ typedef VkFlags VkAccessFlags; typedef enum VkDependencyFlagBits { VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, + VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002, + VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004, VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkDependencyFlagBits; typedef VkFlags VkDependencyFlags; @@ -2388,7 +2459,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); @@ -3024,9 +3095,9 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( VkCommandBuffer commandBuffer, - uint32_t x, - uint32_t y, - uint32_t z); + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, @@ -3225,18 +3296,6 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) typedef enum VkColorSpaceKHR { VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, - VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104001, - VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104002, - VK_COLOR_SPACE_SCRGB_LINEAR_EXT = 1000104003, - VK_COLOR_SPACE_SCRGB_NONLINEAR_EXT = 1000104004, - VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104005, - VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104006, - VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104007, - VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104008, - VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104009, - VK_COLOR_SPACE_BT2020_NONLINEAR_EXT = 1000104010, - VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, - VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1), @@ -3339,6 +3398,11 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) #define VK_KHR_SWAPCHAIN_SPEC_VERSION 68 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" + +typedef enum VkSwapchainCreateFlagBitsKHR { + VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001, + VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSwapchainCreateFlagBitsKHR; typedef VkFlags VkSwapchainCreateFlagsKHR; typedef struct VkSwapchainCreateInfoKHR { @@ -3902,10 +3966,105 @@ VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( VkCommandPoolTrimFlagsKHR flags); #endif +#define VK_KHR_push_descriptor 1 +#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1 +#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" + +typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorPropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); +#endif + +#define VK_KHR_descriptor_update_template 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR) + +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" + + +typedef enum VkDescriptorUpdateTemplateTypeKHR { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + 1), + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDescriptorUpdateTemplateTypeKHR; + +typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR; + +typedef struct VkDescriptorUpdateTemplateEntryKHR { + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + size_t offset; + size_t stride; +} VkDescriptorUpdateTemplateEntryKHR; + +typedef struct VkDescriptorUpdateTemplateCreateInfoKHR { + VkStructureType sType; + void* pNext; + VkDescriptorUpdateTemplateCreateFlagsKHR flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateTypeKHR templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint32_t set; +} VkDescriptorUpdateTemplateCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData); +#endif + #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) -#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 4 +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 5 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" #define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT @@ -4060,7 +4219,7 @@ typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { #define VK_EXT_debug_marker 1 -#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 3 +#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" typedef struct VkDebugMarkerObjectNameInfoEXT { @@ -4188,6 +4347,38 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" +#define VK_KHX_multiview 1 +#define VK_KHX_MULTIVIEW_SPEC_VERSION 1 +#define VK_KHX_MULTIVIEW_EXTENSION_NAME "VK_KHX_multiview" + +typedef struct VkRenderPassMultiviewCreateInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfoKHX; + +typedef struct VkPhysicalDeviceMultiviewFeaturesKHX { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeaturesKHX; + +typedef struct VkPhysicalDeviceMultiviewPropertiesKHX { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewPropertiesKHX; + + + #define VK_IMG_format_pvrtc 1 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" @@ -4306,6 +4497,204 @@ typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { #endif /* VK_USE_PLATFORM_WIN32_KHR */ +#define VK_KHX_device_group 1 +#define VK_MAX_DEVICE_GROUP_SIZE_KHX 32 +#define VK_KHX_DEVICE_GROUP_SPEC_VERSION 1 +#define VK_KHX_DEVICE_GROUP_EXTENSION_NAME "VK_KHX_device_group" + + +typedef enum VkPeerMemoryFeatureFlagBitsKHX { + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 0x00000001, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 0x00000002, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x00000004, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x00000008, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkPeerMemoryFeatureFlagBitsKHX; +typedef VkFlags VkPeerMemoryFeatureFlagsKHX; + +typedef enum VkMemoryAllocateFlagBitsKHX { + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x00000001, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkMemoryAllocateFlagBitsKHX; +typedef VkFlags VkMemoryAllocateFlagsKHX; + +typedef enum VkDeviceGroupPresentModeFlagBitsKHX { + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 0x00000001, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 0x00000002, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 0x00000004, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x00000008, + VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkDeviceGroupPresentModeFlagBitsKHX; +typedef VkFlags VkDeviceGroupPresentModeFlagsKHX; + +typedef struct VkMemoryAllocateFlagsInfoKHX { + VkStructureType sType; + const void* pNext; + VkMemoryAllocateFlagsKHX flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfoKHX; + +typedef struct VkBindBufferMemoryInfoKHX { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindBufferMemoryInfoKHX; + +typedef struct VkBindImageMemoryInfoKHX { + VkStructureType sType; + const void* pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t SFRRectCount; + const VkRect2D* pSFRRects; +} VkBindImageMemoryInfoKHX; + +typedef struct VkDeviceGroupRenderPassBeginInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfoKHX; + +typedef struct VkDeviceGroupCommandBufferBeginInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfoKHX; + +typedef struct VkDeviceGroupSubmitInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfoKHX; + +typedef struct VkDeviceGroupBindSparseInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfoKHX; + +typedef struct VkDeviceGroupPresentCapabilitiesKHX { + VkStructureType sType; + const void* pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX]; + VkDeviceGroupPresentModeFlagsKHX modes; +} VkDeviceGroupPresentCapabilitiesKHX; + +typedef struct VkImageSwapchainCreateInfoKHX { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; +} VkImageSwapchainCreateInfoKHX; + +typedef struct VkBindImageMemorySwapchainInfoKHX { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHX; + +typedef struct VkAcquireNextImageInfoKHX { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHX; + +typedef struct VkDeviceGroupPresentInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHX mode; +} VkDeviceGroupPresentInfoKHX; + +typedef struct VkDeviceGroupSwapchainCreateInfoKHX { + VkStructureType sType; + const void* pNext; + VkDeviceGroupPresentModeFlagsKHX modes; +} VkDeviceGroupSwapchainCreateInfoKHX; + + +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHX)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHX* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHX)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHX* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHX)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHX)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHX)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHX* pModes); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHX)(VkDevice device, const VkAcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHX)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHX)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHX( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHX( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfoKHX* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHX( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfoKHX* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHX( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHX( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHX( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHX* pModes); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHX( + VkDevice device, + const VkAcquireNextImageInfoKHX* pAcquireInfo, + uint32_t* pImageIndex); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHX( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); +#endif + #define VK_EXT_validation_flags 1 #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" @@ -4364,6 +4753,403 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" +#define VK_KHX_device_group_creation 1 +#define VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION 1 +#define VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHX_device_group_creation" + +typedef struct VkPhysicalDeviceGroupPropertiesKHX { + VkStructureType sType; + const void* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupPropertiesKHX; + +typedef struct VkDeviceGroupDeviceCreateInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t physicalDeviceCount; + const VkPhysicalDevice* pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfoKHX; + + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHX)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties); +#endif + +#define VK_KHX_external_memory_capabilities 1 +#define VK_LUID_SIZE_KHX 8 +#define VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHX_external_memory_capabilities" + + +typedef enum VkExternalMemoryHandleTypeFlagBitsKHX { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsKHX; +typedef VkFlags VkExternalMemoryHandleTypeFlagsKHX; + +typedef enum VkExternalMemoryFeatureFlagBitsKHX { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsKHX; +typedef VkFlags VkExternalMemoryFeatureFlagsKHX; + +typedef struct VkExternalMemoryPropertiesKHX { + VkExternalMemoryFeatureFlagsKHX externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes; +} VkExternalMemoryPropertiesKHX; + +typedef struct VkPhysicalDeviceExternalImageFormatInfoKHX { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHX handleType; +} VkPhysicalDeviceExternalImageFormatInfoKHX; + +typedef struct VkExternalImageFormatPropertiesKHX { + VkStructureType sType; + void* pNext; + VkExternalMemoryPropertiesKHX externalMemoryProperties; +} VkExternalImageFormatPropertiesKHX; + +typedef struct VkPhysicalDeviceExternalBufferInfoKHX { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBitsKHX handleType; +} VkPhysicalDeviceExternalBufferInfoKHX; + +typedef struct VkExternalBufferPropertiesKHX { + VkStructureType sType; + void* pNext; + VkExternalMemoryPropertiesKHX externalMemoryProperties; +} VkExternalBufferPropertiesKHX; + +typedef struct VkPhysicalDeviceIDPropertiesKHX { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE_KHX]; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDPropertiesKHX; + +typedef struct VkPhysicalDeviceProperties2KHX { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties properties; +} VkPhysicalDeviceProperties2KHX; + +typedef struct VkImageFormatProperties2KHX { + VkStructureType sType; + void* pNext; + VkImageFormatProperties imageFormatProperties; +} VkImageFormatProperties2KHX; + +typedef struct VkPhysicalDeviceImageFormatInfo2KHX { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2KHX; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHX)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHX* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHX* pImageFormatInfo, VkImageFormatProperties2KHX* pImageFormatProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHX( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, + VkExternalBufferPropertiesKHX* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHX( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHX* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHX( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2KHX* pImageFormatInfo, + VkImageFormatProperties2KHX* pImageFormatProperties); +#endif + +#define VK_KHX_external_memory 1 +#define VK_KHX_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_KHX_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHX_external_memory" +#define VK_QUEUE_FAMILY_EXTERNAL_KHX (~0U-1) + +typedef struct VkExternalMemoryImageCreateInfoKHX { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHX handleTypes; +} VkExternalMemoryImageCreateInfoKHX; + +typedef struct VkExternalMemoryBufferCreateInfoKHX { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHX handleTypes; +} VkExternalMemoryBufferCreateInfoKHX; + +typedef struct VkExportMemoryAllocateInfoKHX { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHX handleTypes; +} VkExportMemoryAllocateInfoKHX; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHX_external_memory_win32 1 +#define VK_KHX_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHX_external_memory_win32" + +typedef struct VkImportMemoryWin32HandleInfoKHX { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHX handleType; + HANDLE handle; +} VkImportMemoryWin32HandleInfoKHX; + +typedef struct VkExportMemoryWin32HandleInfoKHX { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHX; + +typedef struct VkMemoryWin32HandlePropertiesKHX { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryWin32HandlePropertiesKHX; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHX)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHX)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHX( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagBitsKHX handleType, + HANDLE* pHandle); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHX( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHX handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHX_external_memory_fd 1 +#define VK_KHX_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHX_external_memory_fd" + +typedef struct VkImportMemoryFdInfoKHX { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHX handleType; + int fd; +} VkImportMemoryFdInfoKHX; + +typedef struct VkMemoryFdPropertiesKHX { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHX; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHX)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHX)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, VkMemoryFdPropertiesKHX* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHX( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagBitsKHX handleType, + int* pFd); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHX( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHX handleType, + int fd, + VkMemoryFdPropertiesKHX* pMemoryFdProperties); +#endif + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHX_win32_keyed_mutex 1 +#define VK_KHX_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_KHX_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHX_win32_keyed_mutex" + +typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoKHX; + + +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHX_external_semaphore_capabilities 1 +#define VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHX_external_semaphore_capabilities" + + +typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHX { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkExternalSemaphoreHandleTypeFlagBitsKHX; +typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHX; + +typedef enum VkExternalSemaphoreFeatureFlagBitsKHX { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF +} VkExternalSemaphoreFeatureFlagBitsKHX; +typedef VkFlags VkExternalSemaphoreFeatureFlagsKHX; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHX { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBitsKHX handleType; +} VkPhysicalDeviceExternalSemaphoreInfoKHX; + +typedef struct VkExternalSemaphorePropertiesKHX { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes; + VkExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures; +} VkExternalSemaphorePropertiesKHX; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHX( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties); +#endif + +#define VK_KHX_external_semaphore 1 +#define VK_KHX_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_KHX_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHX_external_semaphore" + +typedef struct VkExportSemaphoreCreateInfoKHX { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagsKHX handleTypes; +} VkExportSemaphoreCreateInfoKHX; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHX +#define VK_KHX_external_semaphore_win32 1 +#define VK_KHX_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 +#define VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHX_external_semaphore_win32" + +typedef struct VkImportSemaphoreWin32HandleInfoKHX { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagsKHX handleType; + HANDLE handle; +} VkImportSemaphoreWin32HandleInfoKHX; + +typedef struct VkExportSemaphoreWin32HandleInfoKHX { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportSemaphoreWin32HandleInfoKHX; + +typedef struct VkD3D12FenceSubmitInfoKHX { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; +} VkD3D12FenceSubmitInfoKHX; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHX)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHX)(VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHX( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHX( + VkDevice device, + VkSemaphore semaphore, + VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, + HANDLE* pHandle); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHX */ + +#define VK_KHX_external_semaphore_fd 1 +#define VK_KHX_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHX_external_semaphore_fd" + +typedef struct VkImportSemaphoreFdInfoKHX { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBitsKHX handleType; + int fd; +} VkImportSemaphoreFdInfoKHX; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHX)(VkDevice device, const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHX)(VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHX( + VkDevice device, + const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHX( + VkDevice device, + VkSemaphore semaphore, + VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, + int* pFd); +#endif + #define VK_NVX_device_generated_commands 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) @@ -4591,6 +5377,34 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkDeviceGeneratedCommandsLimitsNVX* pLimits); #endif +#define VK_NV_clip_space_w_scaling 1 +#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 +#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" + +typedef struct VkViewportWScalingNV { + float xcoeff; + float ycoeff; +} VkViewportWScalingNV; + +typedef struct VkPipelineViewportWScalingStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV* pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings); +#endif + #define VK_EXT_direct_mode_display 1 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" @@ -4751,11 +5565,166 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( uint64_t* pCounterValue); #endif -#define VK_EXT_swapchain_colorspace 1 -#define VK_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 1 -#define VK_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" +#define VK_NV_sample_mask_override_coverage 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" + + +#define VK_NV_geometry_shader_passthrough 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" + + +#define VK_NV_viewport_array2 1 +#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2" + + +#define VK_NVX_multiview_per_view_attributes 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" + +typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + VkStructureType sType; + void* pNext; + VkBool32 perViewPositionAllComponents; +} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + + + +#define VK_NV_viewport_swizzle 1 +#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" + + +typedef enum VkViewportCoordinateSwizzleNV { + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV, + VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1), + VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF +} VkViewportCoordinateSwizzleNV; + +typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; + +typedef struct VkViewportSwizzleNV { + VkViewportCoordinateSwizzleNV x; + VkViewportCoordinateSwizzleNV y; + VkViewportCoordinateSwizzleNV z; + VkViewportCoordinateSwizzleNV w; +} VkViewportSwizzleNV; + +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const VkViewportSwizzleNV* pViewportSwizzles; +} VkPipelineViewportSwizzleStateCreateInfoNV; + +#define VK_EXT_discard_rectangles 1 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 +#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" + + +typedef enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, + VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT, + VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1), + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDiscardRectangleModeEXT; + +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; + +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + const void* pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D* pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + + +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles); +#endif + +#ifdef VK_USE_PLATFORM_IOS_MVK +#define VK_MVK_ios_surface 1 +#define VK_MVK_IOS_SURFACE_SPEC_VERSION 2 +#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" + +typedef VkFlags VkIOSSurfaceCreateFlagsMVK; + +typedef struct VkIOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkIOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkIOSSurfaceCreateInfoMVK; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif /* VK_USE_PLATFORM_IOS_MVK */ + +#ifdef VK_USE_PLATFORM_MACOS_MVK +#define VK_MVK_macos_surface 1 +#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2 +#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" + +typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; + +typedef struct VkMacOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkMacOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkMacOSSurfaceCreateInfoMVK; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( + VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif /* VK_USE_PLATFORM_MACOS_MVK */ + #ifdef __cplusplus } #endif diff --git a/src/vulkan/registry/vk.xml b/src/vulkan/registry/vk.xml index 779875b8193..3d2b95ba6db 100644 --- a/src/vulkan/registry/vk.xml +++ b/src/vulkan/registry/vk.xml @@ -63,6 +63,10 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <tag name="TIZEN" author="Samsung Electronics Co., Ltd." contact="Alon Or-bach @alonorbach"/> <tag name="RENDERDOC" author="RenderDoc (renderdoc.org)" contact="[email protected]"/> <tag name="NN" author="Nintendo Co., Ltd." contact="Yasuhiro Yoshioka @yoshioka_yasuhiro"/> + <tag name="MVK" author="The Brenwill Workshop Ltd." contact="Bill Hollings @billhollings"/> + <tag name="KHR" author="Khronos" contact="Tom Olson @tom.olson"/> + <tag name="EXT" author="Multivendor" contact="Jon Leech @oddhack"/> + <tag name="MESA" author="Mesa open source project" contact="Chad Versace @chadversary, Daniel Stone @fooishbar, David Airlie @airlied, Jason Ekstrand @jekstrand"/> </tags> <!-- SECTION: Vulkan type definitions --> @@ -92,6 +96,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type requires="windows.h" name="HANDLE"/> <type requires="windows.h" name="SECURITY_ATTRIBUTES"/> <type requires="windows.h" name="DWORD"/> + <type requires="windows.h" name="LPCWSTR"/> <type requires="xcb/xcb.h" name="xcb_connection_t"/> <type requires="xcb/xcb.h" name="xcb_visualid_t"/> <type requires="xcb/xcb.h" name="xcb_window_t"/> @@ -107,7 +112,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type category="define">// Vulkan 1.0 version number #define <name>VK_API_VERSION_1_0</name> <type>VK_MAKE_VERSION</type>(1, 0, 0)</type> <!-- The patch version here should never be set to anything other than 0 --> <type category="define">// Version of this file -#define <name>VK_HEADER_VERSION</name> 39</type> +#define <name>VK_HEADER_VERSION</name> 42</type> <type category="define"> #define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type> @@ -139,6 +144,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type requires="vk_platform" name="uint64_t"/> <type requires="vk_platform" name="int32_t"/> <type requires="vk_platform" name="size_t"/> + <type name="int"/> <!-- Bitmask types --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkFramebufferCreateFlags</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkQueryPoolCreateFlags</name>;</type> <!-- creation flags --> @@ -156,7 +162,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineInputAssemblyStateCreateFlags</name>;</type><!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineVertexInputStateCreateFlags</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineShaderStageCreateFlags</name>;</type> <!-- creation flags --> - <type category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorSetLayoutCreateFlags</name>;</type> <!-- creation flags --> + <type requires="VkDescriptorSetLayoutCreateFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorSetLayoutCreateFlags</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkBufferViewCreateFlags</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkInstanceCreateFlags</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkDeviceCreateFlags</name>;</type> <!-- creation flags --> @@ -189,7 +195,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type requires="VkImageAspectFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkImageAspectFlags</name>;</type> <!-- Bitmask of image aspects --> <type requires="VkSparseMemoryBindFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSparseMemoryBindFlags</name>;</type> <!-- Sparse memory bind flags --> <type requires="VkSparseImageFormatFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSparseImageFormatFlags</name>;</type> <!-- Sparse image memory requirements flags --> - <type category="bitmask">typedef <type>VkFlags</type> <name>VkSubpassDescriptionFlags</name>;</type> <!-- Subpass description flags --> + <type requires="VkSubpassDescriptionFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSubpassDescriptionFlags</name>;</type> <!-- Subpass description flags --> <type requires="VkPipelineStageFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineStageFlags</name>;</type> <!-- Pipeline stages --> <type requires="VkSampleCountFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkSampleCountFlags</name>;</type> <!-- Pipeline stages --> <type requires="VkAttachmentDescriptionFlagBits" category="bitmask">typedef <type>VkFlags</type> <name>VkAttachmentDescriptionFlags</name>;</type> <!-- Render pass attachment description flags --> @@ -202,26 +208,38 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type requires="VkIndirectCommandsLayoutUsageFlagBitsNVX" category="bitmask">typedef <type>VkFlags</type> <name>VkIndirectCommandsLayoutUsageFlagsNVX</name>;</type> <!-- Device generated commands usage flags --> <type requires="VkObjectEntryUsageFlagBitsNVX" category="bitmask">typedef <type>VkFlags</type> <name>VkObjectEntryUsageFlagsNVX</name>;</type> <!-- Object usage flags --> + <type category="bitmask">typedef <type>VkFlags</type> <name>VkDescriptorUpdateTemplateCreateFlagsKHR</name>;</type> <!-- Descriptor update template creation flags --> <!-- WSI extensions --> <type requires="VkCompositeAlphaFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkCompositeAlphaFlagsKHR</name>;</type> <type requires="VkDisplayPlaneAlphaFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkDisplayPlaneAlphaFlagsKHR</name>;</type> <type requires="VkSurfaceTransformFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkSurfaceTransformFlagsKHR</name>;</type> - <type category="bitmask">typedef <type>VkFlags</type> <name>VkSwapchainCreateFlagsKHR</name>;</type> <!-- creation flags --> + <type requires="VkSwapchainCreateFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkSwapchainCreateFlagsKHR</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkDisplayModeCreateFlagsKHR</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkDisplaySurfaceCreateFlagsKHR</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkAndroidSurfaceCreateFlagsKHR</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkMirSurfaceCreateFlagsKHR</name>;</type> <!-- creation flags --> - <type category="bitmask">typedef <type>VkFlags</type> <name>VkViSurfaceCreateFlagsNN</name>;</type> <!-- creation flags --> + <type category="bitmask">typedef <type>VkFlags</type> <name>VkViSurfaceCreateFlagsNN</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkWaylandSurfaceCreateFlagsKHR</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkWin32SurfaceCreateFlagsKHR</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkXlibSurfaceCreateFlagsKHR</name>;</type> <!-- creation flags --> <type category="bitmask">typedef <type>VkFlags</type> <name>VkXcbSurfaceCreateFlagsKHR</name>;</type> <!-- creation flags --> + <type category="bitmask">typedef <type>VkFlags</type> <name>VkIOSSurfaceCreateFlagsMVK</name>;</type> <!-- creation flags --> + <type category="bitmask">typedef <type>VkFlags</type> <name>VkMacOSSurfaceCreateFlagsMVK</name>;</type> <!-- creation flags --> + <type requires="VkPeerMemoryFeatureFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkPeerMemoryFeatureFlagsKHX</name>;</type> <!-- Peer memory feature flags --> + <type requires="VkMemoryAllocateFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkMemoryAllocateFlagsKHX</name>;</type> <!-- Memory allocation flags --> + <type requires="VkDeviceGroupPresentModeFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkDeviceGroupPresentModeFlagsKHX</name>;</type><!-- Device group present mode flags --> <type requires="VkDebugReportFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkDebugReportFlagsEXT</name>;</type> <type category="bitmask">typedef <type>VkFlags</type> <name>VkCommandPoolTrimFlagsKHR</name>;</type> <type requires="VkExternalMemoryHandleTypeFlagBitsNV" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryHandleTypeFlagsNV</name>;</type> <type requires="VkExternalMemoryFeatureFlagBitsNV" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryFeatureFlagsNV</name>;</type> + <type requires="VkExternalMemoryHandleTypeFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryHandleTypeFlagsKHX</name>;</type> + <type requires="VkExternalMemoryFeatureFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryFeatureFlagsKHX</name>;</type> + <type requires="VkExternalSemaphoreHandleTypeFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalSemaphoreHandleTypeFlagsKHX</name>;</type> + <type requires="VkExternalSemaphoreFeatureFlagBitsKHX" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalSemaphoreFeatureFlagsKHX</name>;</type> <type requires="VkSurfaceCounterFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkSurfaceCounterFlagsEXT</name>;</type> + <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineViewportSwizzleStateCreateFlagsNV</name>;</type> <!-- creation flags (no bits yet) --> + <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineDiscardRectangleStateCreateFlagsEXT</name>;</type> <!-- creation flags (no bits yet) --> <!-- Types which can be void pointers or class pointers, selected at compile time --> <type category="handle"><type>VK_DEFINE_HANDLE</type>(<name>VkInstance</name>)</type> @@ -251,6 +269,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkPipelineCache</name>)</type> <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkObjectTableNVX</name>)</type> <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkIndirectCommandsLayoutNVX</name>)</type> + <type category="handle" parent="VkDevice"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDescriptorUpdateTemplateKHR</name>)</type> <!-- WSI extensions --> <type category="handle"><type>VK_DEFINE_NON_DISPATCHABLE_HANDLE</type>(<name>VkDisplayKHR</name>)</type> @@ -350,6 +369,10 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkIndirectCommandsTokenTypeNVX" category="enum"/> <type name="VkObjectEntryUsageFlagBitsNVX" category="enum"/> <type name="VkObjectEntryTypeNVX" category="enum"/> + <type name="VkDescriptorUpdateTemplateTypeKHR" category="enum"/> + <type name="VkViewportCoordinateSwizzleNV" category="enum"/> + <type name="VkDiscardRectangleModeEXT" category="enum"/> + <type name="VkSubpassDescriptionFlagBits" category="enum"/> <!-- WSI extensions --> <type name="VkColorSpaceKHR" category="enum"/> <type name="VkCompositeAlphaFlagBitsKHR" category="enum"/> @@ -363,10 +386,18 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkExternalMemoryHandleTypeFlagBitsNV" category="enum"/> <type name="VkExternalMemoryFeatureFlagBitsNV" category="enum"/> <type name="VkValidationCheckEXT" category="enum"/> + <type name="VkExternalMemoryHandleTypeFlagBitsKHX" category="enum"/> + <type name="VkExternalMemoryFeatureFlagBitsKHX" category="enum"/> + <type name="VkExternalSemaphoreHandleTypeFlagBitsKHX" category="enum"/> + <type name="VkExternalSemaphoreFeatureFlagBitsKHX" category="enum"/> <type name="VkSurfaceCounterFlagBitsEXT" category="enum"/> <type name="VkDisplayPowerStateEXT" category="enum"/> <type name="VkDeviceEventTypeEXT" category="enum"/> <type name="VkDisplayEventTypeEXT" category="enum"/> + <type name="VkPeerMemoryFeatureFlagBitsKHX" category="enum"/> + <type name="VkMemoryAllocateFlagBitsKHX" category="enum"/> + <type name="VkDeviceGroupPresentModeFlagBitsKHX" category="enum"/> + <type name="VkSwapchainCreateFlagBitsKHR" category="enum"/> <!-- The PFN_vk*Function types are used by VkAllocationCallbacks below --> <type category="funcpointer">typedef void (VKAPI_PTR *<name>PFN_vkInternalAllocationNotification</name>)( @@ -502,7 +533,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkDeviceCreateInfo"> <member values="VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member validextensionstructs="VkPhysicalDeviceFeatures2KHR">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkPhysicalDeviceFeatures2KHR,VkPhysicalDeviceMultiviewFeaturesKHX,VkDeviceGroupDeviceCreateInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkDeviceCreateFlags</type> <name>flags</name></member> <!-- Reserved --> <member><type>uint32_t</type> <name>queueCreateInfoCount</name></member> <member len="queueCreateInfoCount">const <type>VkDeviceQueueCreateInfo</type>* <name>pQueueCreateInfos</name></member> @@ -536,7 +567,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkMemoryAllocateInfo"> <member values="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member validextensionstructs="VkDedicatedAllocationMemoryAllocateInfoNV">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkDedicatedAllocationMemoryAllocateInfoNV,VkMemoryAllocateFlagsInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member><type>VkDeviceSize</type> <name>allocationSize</name></member> <!-- Size of memory allocation --> <member><type>uint32_t</type> <name>memoryTypeIndex</name></member> <!-- Index of the of the memory type to allocate from --> </type> @@ -685,7 +716,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkImageCreateInfo"> <member values="VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member validextensionstructs="VkDedicatedAllocationImageCreateInfoNV">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure. --> + <member validextensionstructs="VkDedicatedAllocationImageCreateInfoNV,VkImageSwapchainCreateInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure. --> <member optional="true"><type>VkImageCreateFlags</type> <name>flags</name></member> <!-- Image creation flags --> <member><type>VkImageType</type> <name>imageType</name></member> <member><type>VkFormat</type> <name>format</name></member> @@ -754,7 +785,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkBindSparseInfo"> <member values="VK_STRUCTURE_TYPE_BIND_SPARSE_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure. --> + <member validextensionstructs="VkDeviceGroupBindSparseInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure. --> <member optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name></member> <member len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name></member> <member optional="true"><type>uint32_t</type> <name>bufferBindCount</name></member> @@ -799,7 +830,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkShaderModuleCreateFlags</type> <name>flags</name></member> <!-- Reserved --> <member><type>size_t</type> <name>codeSize</name></member> <!-- Specified in bytes --> - <member len="latexmath:[$codeSize \over 4$]">const <type>uint32_t</type>* <name>pCode</name></member> <!-- Binary code of size codeSize --> + <member len="latexmath:[codeSize \over 4]">const <type>uint32_t</type>* <name>pCode</name></member> <!-- Binary code of size codeSize --> </type> <type category="struct" name="VkDescriptorSetLayoutBinding"> <member><type>uint32_t</type> <name>binding</name></member> <!-- Binding number for this entry --> @@ -898,7 +929,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkPipelineViewportStateCreateInfo"> <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkPipelineViewportWScalingStateCreateInfoNV">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkPipelineViewportStateCreateFlags</type> <name>flags</name></member> <!-- Reserved --> <member><type>uint32_t</type> <name>viewportCount</name></member> <member noautovalidity="true" optional="true" len="viewportCount">const <type>VkViewport</type>* <name>pViewports</name></member> @@ -927,7 +958,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <member><type>VkSampleCountFlagBits</type> <name>rasterizationSamples</name></member> <!-- Number of samples used for rasterization --> <member><type>VkBool32</type> <name>sampleShadingEnable</name></member> <!-- optional (GL45) --> <member><type>float</type> <name>minSampleShading</name></member> <!-- optional (GL45) --> - <member optional="true" len="latexmath:[$\lceil{\mathit{rasterizationSamples} \over 32}\rceil$]">const <type>VkSampleMask</type>* <name>pSampleMask</name></member> <!-- Array of sampleMask words --> + <member optional="true" len="latexmath:[\lceil{\mathit{rasterizationSamples} \over 32}\rceil]">const <type>VkSampleMask</type>* <name>pSampleMask</name></member> <!-- Array of sampleMask words --> <member><type>VkBool32</type> <name>alphaToCoverageEnable</name></member> <member><type>VkBool32</type> <name>alphaToOneEnable</name></member> </type> @@ -1068,13 +1099,13 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkCommandBufferBeginInfo"> <member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkDeviceGroupCommandBufferBeginInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkCommandBufferUsageFlags</type> <name>flags</name></member> <!-- Command buffer usage flags --> <member optional="true" noautovalidity="true">const <type>VkCommandBufferInheritanceInfo</type>* <name>pInheritanceInfo</name></member> <!-- Pointer to inheritance info for secondary command buffers --> </type> <type category="struct" name="VkRenderPassBeginInfo"> <member values="VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkDeviceGroupRenderPassBeginInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member><type>VkRenderPass</type> <name>renderPass</name></member> <member><type>VkFramebuffer</type> <name>framebuffer</name></member> <member><type>VkRect2D</type> <name>renderArea</name></member> @@ -1381,7 +1412,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkSubmitInfo"> <member values="VK_STRUCTURE_TYPE_SUBMIT_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkWin32KeyedMutexAcquireReleaseInfoNV,VkWin32KeyedMutexAcquireReleaseInfoKHX,VkD3D12FenceSubmitInfoKHX,VkDeviceGroupSubmitInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name></member> <member len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name></member> <member len="waitSemaphoreCount">const <type>VkPipelineStageFlags</type>* <name>pWaitDstStageMask</name></member> @@ -1513,7 +1544,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkSwapchainCreateInfoKHR"> <member values="VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkDeviceGroupSwapchainCreateInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkSwapchainCreateFlagsKHR</type> <name>flags</name></member> <!-- Reserved --> <member><type>VkSurfaceKHR</type> <name>surface</name></member> <!-- The swapchain's target surface --> <member><type>uint32_t</type> <name>minImageCount</name></member> <!-- Minimum number of presentation images the application needs --> @@ -1533,12 +1564,12 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkPresentInfoKHR"> <member values="VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> - <member validextensionstructs="VkDisplayPresentInfoKHR">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkDeviceGroupPresentInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name></member> <!-- Number of semaphores to wait for before presenting --> <member optional="true" len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name></member> <!-- Semaphores to wait for before presenting --> - <member><type>uint32_t</type> <name>swapchainCount</name></member> <!-- Number of swap chains to present in this call --> + <member><type>uint32_t</type> <name>swapchainCount</name></member> <!-- Number of swapchains to present in this call --> <member len="swapchainCount">const <type>VkSwapchainKHR</type>* <name>pSwapchains</name></member> <!-- Swapchains to present an image from --> - <member len="swapchainCount">const <type>uint32_t</type>* <name>pImageIndices</name></member> <!-- Indices of which swapchain images to present --> + <member len="swapchainCount">const <type>uint32_t</type>* <name>pImageIndices</name></member> <!-- Indices of which presentable images to present --> <member optional="true" len="swapchainCount"><type>VkResult</type>* <name>pResults</name></member> <!-- Optional (i.e. if non-NULL) VkResult for each swapchain --> </type> <type category="struct" name="VkDebugReportCallbackCreateInfoEXT"> @@ -1636,7 +1667,6 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <member len="releaseCount">const <type>VkDeviceMemory</type>* <name>pReleaseSyncs</name></member> <member len="releaseCount">const <type>uint64_t</type>* <name>pReleaseKeys</name></member> </type> - <type category="struct" name="VkDeviceGeneratedCommandsFeaturesNVX"> <member values="VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX"><type>VkStructureType</type> <name>sType</name></member> <member>const <type>void</type>* <name>pNext</name></member> @@ -1739,12 +1769,12 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkPhysicalDeviceFeatures2KHR"> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR"><type>VkStructureType</type> <name>sType</name></member> - <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkPhysicalDeviceMultiviewFeaturesKHX"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member><type>VkPhysicalDeviceFeatures</type> <name>features</name></member> </type> <type category="struct" name="VkPhysicalDeviceProperties2KHR" returnedonly="true"> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member> - <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkPhysicalDevicePushDescriptorPropertiesKHR,VkPhysicalDeviceIDPropertiesKHX,VkPhysicalDeviceMultiviewPropertiesKHX,VkPhysicalDeviceDiscardRectanglePropertiesEXT,VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member><type>VkPhysicalDeviceProperties</type> <name>properties</name></member> </type> <type category="struct" name="VkFormatProperties2KHR" returnedonly="true"> @@ -1754,12 +1784,12 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkImageFormatProperties2KHR" returnedonly="true"> <member values="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR"><type>VkStructureType</type> <name>sType</name></member> - <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkExternalImageFormatPropertiesKHX"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member><type>VkImageFormatProperties</type> <name>imageFormatProperties</name></member> </type> <type category="struct" name="VkPhysicalDeviceImageFormatInfo2KHR"> <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkPhysicalDeviceExternalImageFormatInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member><type>VkFormat</type> <name>format</name></member> <member><type>VkImageType</type> <name>type</name></member> <member><type>VkImageTiling</type> <name>tiling</name></member> @@ -1790,6 +1820,189 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <member><type>VkImageUsageFlags</type> <name>usage</name></member> <member><type>VkImageTiling</type> <name>tiling</name></member> </type> + <type category="struct" name="VkPhysicalDevicePushDescriptorPropertiesKHR"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>maxPushDescriptors</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceProperties2KHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member validextensionstructs="VkPhysicalDeviceIDPropertiesKHX"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkPhysicalDeviceProperties</type> <name>properties</name></member> + </type> + <type category="struct" name="VkImageFormatProperties2KHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member validextensionstructs="VkExternalImageFormatPropertiesKHX"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkImageFormatProperties</type> <name>imageFormatProperties</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceImageFormatInfo2KHX"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member validextensionstructs="VkPhysicalDeviceExternalImageFormatInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkFormat</type> <name>format</name></member> + <member><type>VkImageType</type> <name>type</name></member> + <member><type>VkImageTiling</type> <name>tiling</name></member> + <member><type>VkImageUsageFlags</type> <name>usage</name></member> + <member optional="true"><type>VkImageCreateFlags</type> <name>flags</name></member> + </type> + <type category="struct" name="VkExternalMemoryPropertiesKHX" returnedonly="true"> + <member><type>VkExternalMemoryFeatureFlagsKHX</type> <name>externalMemoryFeatures</name></member> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>exportFromImportedHandleTypes</name></member> + <member><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>compatibleHandleTypes</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceExternalImageFormatInfoKHX"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></member> + </type> + <type category="struct" name="VkExternalImageFormatPropertiesKHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkExternalMemoryPropertiesKHX</type> <name>externalMemoryProperties</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceExternalBufferInfoKHX"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkBufferCreateFlags</type> <name>flags</name></member> + <member><type>VkBufferUsageFlags</type> <name>usage</name></member> + <member><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></member> + </type> + <type category="struct" name="VkExternalBufferPropertiesKHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkExternalMemoryPropertiesKHX</type> <name>externalMemoryProperties</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceIDPropertiesKHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint8_t</type> <name>deviceUUID</name>[<enum>VK_UUID_SIZE</enum>]</member> + <member><type>uint8_t</type> <name>driverUUID</name>[<enum>VK_UUID_SIZE</enum>]</member> + <member><type>uint8_t</type> <name>deviceLUID</name>[<enum>VK_LUID_SIZE_KHX</enum>]</member> + <member><type>VkBool32</type> <name>deviceLUIDValid</name></member> + </type> + <type category="struct" name="VkExternalMemoryImageCreateInfoKHX"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>handleTypes</name></member> + </type> + <type category="struct" name="VkExternalMemoryBufferCreateInfoKHX"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>handleTypes</name></member> + </type> + <type category="struct" name="VkExportMemoryAllocateInfoKHX"> + <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagsKHX</type> <name>handleTypes</name></member> + </type> + <type category="struct" name="VkImportMemoryWin32HandleInfoKHX"> + <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></member> + <member><type>HANDLE</type> <name>handle</name></member> + </type> + <type category="struct" name="VkExportMemoryWin32HandleInfoKHX"> + <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true">const <type>SECURITY_ATTRIBUTES</type>* <name>pAttributes</name></member> + <member><type>DWORD</type> <name>dwAccess</name></member> + <member><type>LPCWSTR</type> <name>name</name></member> + </type> + <type category="struct" name="VkMemoryWin32HandlePropertiesKHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>memoryTypeBits</name></member> + </type> + <type category="struct" name="VkImportMemoryFdInfoKHX"> + <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></member> + <member><type>int</type> <name>fd</name></member> + </type> + <type category="struct" name="VkMemoryFdPropertiesKHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>memoryTypeBits</name></member> + </type> + <type category="struct" name="VkWin32KeyedMutexAcquireReleaseInfoKHX"> + <member values="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>uint32_t</type> <name>acquireCount</name></member> + <member len="acquireCount">const <type>VkDeviceMemory</type>* <name>pAcquireSyncs</name></member> + <member len="acquireCount">const <type>uint64_t</type>* <name>pAcquireKeys</name></member> + <member len="acquireCount">const <type>uint32_t</type>* <name>pAcquireTimeouts</name></member> + <member optional="true"><type>uint32_t</type> <name>releaseCount</name></member> + <member len="releaseCount">const <type>VkDeviceMemory</type>* <name>pReleaseSyncs</name></member> + <member len="releaseCount">const <type>uint64_t</type>* <name>pReleaseKeys</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceExternalSemaphoreInfoKHX"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkExternalSemaphoreHandleTypeFlagBitsKHX</type> <name>handleType</name></member> + </type> + <type category="struct" name="VkExternalSemaphorePropertiesKHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkExternalSemaphoreHandleTypeFlagsKHX</type> <name>exportFromImportedHandleTypes</name></member> + <member><type>VkExternalSemaphoreHandleTypeFlagsKHX</type> <name>compatibleHandleTypes</name></member> + <member optional="true"><type>VkExternalSemaphoreFeatureFlagsKHX</type> <name>externalSemaphoreFeatures</name></member> + </type> + <type category="struct" name="VkExportSemaphoreCreateInfoKHX"> + <member values="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkExternalSemaphoreHandleTypeFlagsKHX</type> <name>handleTypes</name></member> + </type> + <type category="struct" name="VkImportSemaphoreWin32HandleInfoKHX"> + <member values="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkSemaphore</type> <name>semaphore</name></member> + <member><type>VkExternalSemaphoreHandleTypeFlagsKHX</type> <name>handleType</name></member> + <member><type>HANDLE</type> <name>handle</name></member> + </type> + <type category="struct" name="VkExportSemaphoreWin32HandleInfoKHX"> + <member values="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true">const <type>SECURITY_ATTRIBUTES</type>* <name>pAttributes</name></member> + <member><type>DWORD</type> <name>dwAccess</name></member> + <member><type>LPCWSTR</type> <name>name</name></member> + </type> + <type category="struct" name="VkD3D12FenceSubmitInfoKHX"> + <member values="VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>uint32_t</type> <name>waitSemaphoreValuesCount</name></member> + <member optional="true" len="waitSemaphoreValuesCount">const <type>uint64_t</type>* <name>pWaitSemaphoreValues</name></member> + <member optional="true"><type>uint32_t</type> <name>signalSemaphoreValuesCount</name></member> + <member optional="true" len="signalSemaphoreValuesCount">const <type>uint64_t</type>* <name>pSignalSemaphoreValues</name></member> + </type> + <type category="struct" name="VkImportSemaphoreFdInfoKHX"> + <member values="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkSemaphore</type> <name>semaphore</name></member> + <member><type>VkExternalSemaphoreHandleTypeFlagBitsKHX</type> <name>handleType</name></member> + <member><type>int</type> <name>fd</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceMultiviewFeaturesKHX"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBool32</type> <name>multiview</name></member> <!-- Multiple views in a renderpass --> + <member><type>VkBool32</type> <name>multiviewGeometryShader</name></member> <!-- Multiple views in a renderpass w/ geometry shader --> + <member><type>VkBool32</type> <name>multiviewTessellationShader</name></member> <!-- Multiple views in a renderpass w/ tessellation shader --> + </type> + <type category="struct" name="VkPhysicalDeviceMultiviewPropertiesKHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>maxMultiviewViewCount</name></member> <!-- max number of views in a subpass --> + <member><type>uint32_t</type> <name>maxMultiviewInstanceIndex</name></member> <!-- max instance index for a draw in a multiview subpass --> + </type> + <type category="struct" name="VkRenderPassMultiviewCreateInfoKHX"> + <member values="VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>uint32_t</type> <name>subpassCount</name></member> + <member len="subpassCount">const <type>uint32_t</type>* <name>pViewMasks</name></member> + <member optional="true"><type>uint32_t</type> <name>dependencyCount</name></member> + <member len="dependencyCount">const <type>int32_t</type>* <name>pViewOffsets</name></member> + <member optional="true"><type>uint32_t</type> <name>correlationMaskCount</name></member> + <member len="correlationMaskCount">const <type>uint32_t</type>* <name>pCorrelationMasks</name></member> + </type> <type category="struct" name="VkSurfaceCapabilities2EXT" returnedonly="true"> <member values="VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT"><type>VkStructureType</type> <name>sType</name></member> <member><type>void</type>* <name>pNext</name></member> @@ -1825,6 +2038,199 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <member>const <type>void</type>* <name>pNext</name></member> <member optional="true"><type>VkSurfaceCounterFlagsEXT</type> <name>surfaceCounters</name></member> </type> + <type category="struct" name="VkPhysicalDeviceGroupPropertiesKHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>physicalDeviceCount</name></member> + <member><type>VkPhysicalDevice</type> <name>physicalDevices</name>[<enum>VK_MAX_DEVICE_GROUP_SIZE_KHX</enum>]</member> + <member><type>VkBool32</type> <name>subsetAllocation</name></member> + </type> + <type category="struct" name="VkMemoryAllocateFlagsInfoKHX"> + <member values="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkMemoryAllocateFlagsKHX</type> <name>flags</name></member> + <member><type>uint32_t</type> <name>deviceMask</name></member> + </type> + <type category="struct" name="VkBindBufferMemoryInfoKHX"> + <member values="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBuffer</type> <name>buffer</name></member> + <member><type>VkDeviceMemory</type> <name>memory</name></member> + <member><type>VkDeviceSize</type> <name>memoryOffset</name></member> + <member optional="true"><type>uint32_t</type> <name>deviceIndexCount</name></member> + <member len="deviceIndexCount">const <type>uint32_t</type>* <name>pDeviceIndices</name></member> + </type> + <type category="struct" name="VkBindImageMemoryInfoKHX"> + <member values="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member validextensionstructs="VkBindImageMemorySwapchainInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkImage</type> <name>image</name></member> + <member><type>VkDeviceMemory</type> <name>memory</name></member> + <member><type>VkDeviceSize</type> <name>memoryOffset</name></member> + <member optional="true"><type>uint32_t</type> <name>deviceIndexCount</name></member> + <member len="deviceIndexCount">const <type>uint32_t</type>* <name>pDeviceIndices</name></member> + <member optional="true"><type>uint32_t</type> <name>SFRRectCount</name></member> + <member len="SFRRectCount">const <type>VkRect2D</type>* <name>pSFRRects</name></member> + </type> + <type category="struct" name="VkDeviceGroupRenderPassBeginInfoKHX"> + <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>deviceMask</name></member> + <member optional="true"><type>uint32_t</type> <name>deviceRenderAreaCount</name></member> + <member len="deviceRenderAreaCount">const <type>VkRect2D</type>* <name>pDeviceRenderAreas</name></member> + </type> + <type category="struct" name="VkDeviceGroupCommandBufferBeginInfoKHX"> + <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>deviceMask</name></member> + </type> + <type category="struct" name="VkDeviceGroupSubmitInfoKHX"> + <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>uint32_t</type> <name>waitSemaphoreCount</name></member> + <member len="waitSemaphoreCount">const <type>uint32_t</type>* <name>pWaitSemaphoreDeviceIndices</name></member> + <member optional="true"><type>uint32_t</type> <name>commandBufferCount</name></member> + <member len="commandBufferCount">const <type>uint32_t</type>* <name>pCommandBufferDeviceMasks</name></member> + <member optional="true"><type>uint32_t</type> <name>signalSemaphoreCount</name></member> + <member len="signalSemaphoreCount">const <type>uint32_t</type>* <name>pSignalSemaphoreDeviceIndices</name></member> + </type> + <type category="struct" name="VkDeviceGroupBindSparseInfoKHX"> + <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>resourceDeviceIndex</name></member> + <member><type>uint32_t</type> <name>memoryDeviceIndex</name></member> + </type> + <type category="struct" name="VkDeviceGroupPresentCapabilitiesKHX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>presentMask</name>[<enum>VK_MAX_DEVICE_GROUP_SIZE_KHX</enum>]</member> + <member><type>VkDeviceGroupPresentModeFlagsKHX</type> <name>modes</name></member> + </type> + <type category="struct" name="VkImageSwapchainCreateInfoKHX"> + <member values="VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkSwapchainKHR</type> <name>swapchain</name></member> + </type> + <type category="struct" name="VkBindImageMemorySwapchainInfoKHX"> + <member values="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></member> + <member><type>uint32_t</type> <name>imageIndex</name></member> + </type> + <type category="struct" name="VkAcquireNextImageInfoKHX"> + <member values="VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></member> + <member><type>uint64_t</type> <name>timeout</name></member> + <member optional="true" externsync="true"><type>VkSemaphore</type> <name>semaphore</name></member> + <member optional="true" externsync="true"><type>VkFence</type> <name>fence</name></member> + <member><type>uint32_t</type> <name>deviceMask</name></member> + </type> + <type category="struct" name="VkDeviceGroupPresentInfoKHX"> + <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>uint32_t</type> <name>swapchainCount</name></member> + <member len="swapchainCount">const <type>uint32_t</type>* <name>pDeviceMasks</name></member> + <member><type>VkDeviceGroupPresentModeFlagBitsKHX</type> <name>mode</name></member> + </type> + <type category="struct" name="VkDeviceGroupDeviceCreateInfoKHX"> + <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>uint32_t</type> <name>physicalDeviceCount</name></member> + <member len="physicalDeviceCount">const <type>VkPhysicalDevice</type>* <name>pPhysicalDevices</name></member> + </type> + <type category="struct" name="VkDeviceGroupSwapchainCreateInfoKHX"> + <member values="VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkDeviceGroupPresentModeFlagsKHX</type> <name>modes</name></member> + </type> + <type category="struct" name="VkDescriptorUpdateTemplateEntryKHR"> + <member><type>uint32_t</type> <name>dstBinding</name></member> <!-- Binding within the destination descriptor set to write --> + <member><type>uint32_t</type> <name>dstArrayElement</name></member> <!-- Array element within the destination binding to write --> + <member><type>uint32_t</type> <name>descriptorCount</name></member> <!-- Number of descriptors to write --> + <member><type>VkDescriptorType</type> <name>descriptorType</name></member> <!-- Descriptor type to write --> + <member><type>size_t</type> <name>offset</name></member> <!-- Offset into pData where the descriptors to update are stored --> + <member><type>size_t</type> <name>stride</name></member> <!-- Stride between two descriptors in pData when writing more than one descriptor --> + </type> + <type category="struct" name="VkDescriptorUpdateTemplateCreateInfoKHR"> + <member values="VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkDescriptorUpdateTemplateCreateFlagsKHR</type> <name>flags</name></member> <!-- Reserved --> + <member><type>uint32_t</type> <name>descriptorUpdateEntryCount</name></member> <!-- Number of descriptor update entries to use for the update template --> + <member len="descriptorUpdateEntryCount">const <type>VkDescriptorUpdateTemplateEntryKHR</type>* <name>pDescriptorUpdateEntries</name></member> <!-- Descriptor update entries for the template --> + <member><type>VkDescriptorUpdateTemplateTypeKHR</type> <name>templateType</name></member> + <member optional="true"><type>VkDescriptorSetLayout</type> <name>descriptorSetLayout</name></member> + <member optional="true"><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></member> + <member optional="true"><type>VkPipelineLayout</type><name>pipelineLayout</name></member> <!-- If used for push descriptors, this is the only allowed layout --> + <member optional="true"><type>uint32_t</type> <name>set</name></member> + </type> + <type category="struct" name="VkXYColorEXT"> + <!-- chromaticity coordinate --> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + </type> + <type category="struct" name="VkSMPTE2086MetadataEXT"> + <!-- Display primary in chromaticity coordinates --> + <member><type>VkXYColorEXT</type> <name>displayPrimaryRed</name></member> <!-- Display primary's Red --> + <member><type>VkXYColorEXT</type> <name>displayPrimaryGreen</name></member> <!-- Display primary's Green --> + <member><type>VkXYColorEXT</type> <name>displayPrimaryBlue</name></member> <!-- Display primary's Blue --> + <member><type>VkXYColorEXT</type> <name>whitePoint</name></member> <!-- Display primary's Blue --> + <member><type>float</type> <name>maxLuminance</name></member> <!-- Display maximum luminance --> + <member><type>float</type> <name>minLuminance</name></member> <!-- Display minimum luminance --> + </type> + <type category="struct" name="VkIOSSurfaceCreateInfoMVK"> + <member values="VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkIOSSurfaceCreateFlagsMVK</type> <name>flags</name></member> <!-- Reserved --> + <member>const <type>void</type>* <name>pView</name></member> + </type> + <type category="struct" name="VkMacOSSurfaceCreateInfoMVK"> + <member values="VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkMacOSSurfaceCreateFlagsMVK</type> <name>flags</name></member> <!-- Reserved --> + <member>const <type>void</type>* <name>pView</name></member> + </type> + <type category="struct" name="VkViewportWScalingNV"> + <member><type>float</type> <name>xcoeff</name></member> + <member><type>float</type> <name>ycoeff</name></member> + </type> + <type category="struct" name="VkPipelineViewportWScalingStateCreateInfoNV"> + <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBool32</type> <name>viewportWScalingEnable</name></member> + <member><type>uint32_t</type> <name>viewportCount</name></member> + <member noautovalidity="true" len="viewportCount">const <type>VkViewportWScalingNV</type>* <name>pViewportWScalings</name></member> + </type> + <type category="struct" name="VkViewportSwizzleNV"> + <member><type>VkViewportCoordinateSwizzleNV</type> <name>x</name></member> + <member><type>VkViewportCoordinateSwizzleNV</type> <name>y</name></member> + <member><type>VkViewportCoordinateSwizzleNV</type> <name>z</name></member> + <member><type>VkViewportCoordinateSwizzleNV</type> <name>w</name></member> + </type> + <type category="struct" name="VkPipelineViewportSwizzleStateCreateInfoNV"> + <member values="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkPipelineViewportSwizzleStateCreateFlagsNV</type> <name>flags</name></member> <!-- Reserved --> + <member><type>uint32_t</type> <name>viewportCount</name></member> + <member noautovalidity="true" optional="true" len="viewportCount">const <type>VkViewportSwizzleNV</type>* <name>pViewportSwizzles</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceDiscardRectanglePropertiesEXT"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>maxDiscardRectangles</name></member> <!-- max number of active discard rectangles --> + </type> + <type category="struct" name="VkPipelineDiscardRectangleStateCreateInfoEXT"> + <member values="VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkPipelineDiscardRectangleStateCreateFlagsEXT</type> <name>flags</name></member> <!-- Reserved --> + <member><type>VkDiscardRectangleModeEXT</type> <name>discardRectangleMode</name></member> + <member optional="true"><type>uint32_t</type> <name>discardRectangleCount</name></member> + <member noautovalidity="true" optional="true" len="discardRectangleCount">const <type>VkRect2D</type>* <name>pDiscardRectangles</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBool32</type> <name>perViewPositionAllComponents</name></member> + </type> </types> <!-- SECTION: Vulkan enumerant (token) definitions. --> @@ -1833,6 +2239,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <!-- This is part of the header boilerplate --> <enum value="256" name="VK_MAX_PHYSICAL_DEVICE_NAME_SIZE"/> <enum value="16" name="VK_UUID_SIZE"/> + <enum value="8" name="VK_LUID_SIZE_KHX"/> <enum value="256" name="VK_MAX_EXTENSION_NAME_SIZE"/> <enum value="256" name="VK_MAX_DESCRIPTION_SIZE"/> <enum value="32" name="VK_MAX_MEMORY_TYPES"/> @@ -1845,7 +2252,9 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value="1" name="VK_TRUE"/> <enum value="0" name="VK_FALSE"/> <enum value="(~0U)" name="VK_QUEUE_FAMILY_IGNORED"/> + <enum value="(~0U-1)" name="VK_QUEUE_FAMILY_EXTERNAL_KHX"/> <enum value="(~0U)" name="VK_SUBPASS_EXTERNAL"/> + <enum value="32" name="VK_MAX_DEVICE_GROUP_SIZE_KHX"/> </enums> <!-- Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in @@ -2353,6 +2762,10 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value="7" name="VK_DYNAMIC_STATE_STENCIL_WRITE_MASK"/> <enum value="8" name="VK_DYNAMIC_STATE_STENCIL_REFERENCE"/> </enums> + <enums name="VkDescriptorUpdateTemplateTypeKHR" type="enum"> + <enum value="0" name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR" comment="Create descriptor update template for descriptor set updates"/> + <enum value="1" name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR" comment="Create descriptor update template for pushed descriptor updates"/> + </enums> <!-- Flags --> <enums name="VkQueueFlagBits" type="bitmask"> @@ -2680,6 +3093,33 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value="3" name="VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX"/> <enum value="4" name="VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX"/> </enums> + <enums name="VkDescriptorSetLayoutCreateFlagBits" type="bitmask"> + </enums> + <enums name="VkExternalMemoryHandleTypeFlagBitsKHX" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX"/> + <enum bitpos="1" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX"/> + <enum bitpos="2" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX"/> + <enum bitpos="3" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX"/> + <enum bitpos="4" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX"/> + <enum bitpos="5" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX"/> + <enum bitpos="6" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX"/> + </enums> + <enums name="VkExternalMemoryFeatureFlagBitsKHX" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX"/> + <enum bitpos="1" name="VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX"/> + <enum bitpos="2" name="VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX"/> + </enums> + <enums name="VkExternalSemaphoreHandleTypeFlagBitsKHX" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX"/> + <enum bitpos="1" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX"/> + <enum bitpos="2" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX"/> + <enum bitpos="3" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX"/> + <enum bitpos="4" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX"/> + </enums> + <enums name="VkExternalSemaphoreFeatureFlagBitsKHX" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX"/> + <enum bitpos="1" name="VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX"/> + </enums> <enums name="VkSurfaceCounterFlagBitsEXT" type="bitmask"> <enum bitpos="0" name="VK_SURFACE_COUNTER_VBLANK_EXT"/> </enums> @@ -2694,6 +3134,39 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enums name="VkDisplayEventTypeEXT" type="enum"> <enum value="0" name="VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT"/> </enums> + <enums name="VkPeerMemoryFeatureFlagBitsKHX" type="bitmask"> + <enum bitpos="0" name="VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX" comment="Can read with vkCmdCopy commands"/> + <enum bitpos="1" name="VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX" comment="Can write with vkCmdCopy commands"/> + <enum bitpos="2" name="VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX" comment="Can read with any access type/command"/> + <enum bitpos="3" name="VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX" comment="Can write with and access type/command"/> + </enums> + <enums name="VkMemoryAllocateFlagBitsKHX" type="bitmask"> + <enum bitpos="0" name="VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX" comment="Force allocation on specific devices"/> + </enums> + <enums name="VkDeviceGroupPresentModeFlagBitsKHX" type="bitmask"> + <enum bitpos="0" name="VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX" comment="Present from local memory"/> + <enum bitpos="1" name="VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX" comment="Present from remote memory"/> + <enum bitpos="2" name="VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX" comment="Present sum of local and/or remote memory"/> + <enum bitpos="3" name="VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX" comment="Each physical device presents from local memory"/> + </enums> + <enums name="VkSwapchainCreateFlagBitsKHR" type="bitmask"> + </enums> + <enums name="VkViewportCoordinateSwizzleNV" type="enum"> + <enum value="0" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV"/> + <enum value="1" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV"/> + <enum value="2" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV"/> + <enum value="3" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV"/> + <enum value="4" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV"/> + <enum value="5" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV"/> + <enum value="6" name="VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV"/> + <enum value="7" name="VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV"/> + </enums> + <enums name="VkDiscardRectangleModeEXT" type="enum"> + <enum value="0" name="VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT"/> + <enum value="1" name="VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT"/> + </enums> + <enums name="VkSubpassDescriptionFlagBits" type="bitmask"> + </enums> <!-- SECTION: Vulkan command definitions --> <commands> @@ -2822,7 +3295,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <param>all sname:VkQueue objects created from pname:device</param> </implicitexternsyncparams> </command> - <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_TOO_MANY_OBJECTS"> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX"> <proto><type>VkResult</type> <name>vkAllocateMemory</name></proto> <param><type>VkDevice</type> <name>device</name></param> <param>const <type>VkMemoryAllocateInfo</type>* <name>pAllocateInfo</name></param> @@ -3199,7 +3672,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <param>any sname:VkDescriptorSet objects allocated from pname:descriptorPool</param> </implicitexternsyncparams> </command> - <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FRAGMENTED_POOL"> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FRAGMENTED_POOL,VK_ERROR_OUT_OF_POOL_MEMORY_KHR"> <proto><type>VkResult</type> <name>vkAllocateDescriptorSets</name></proto> <param><type>VkDevice</type> <name>device</name></param> <param externsync="pAllocateInfo::descriptorPool">const <type>VkDescriptorSetAllocateInfo</type>* <name>pAllocateInfo</name></param> @@ -3427,9 +3900,9 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary" pipeline="compute"> <proto><type>void</type> <name>vkCmdDispatch</name></proto> <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param> - <param><type>uint32_t</type> <name>x</name></param> - <param><type>uint32_t</type> <name>y</name></param> - <param><type>uint32_t</type> <name>z</name></param> + <param><type>uint32_t</type> <name>groupCountX</name></param> + <param><type>uint32_t</type> <name>groupCountY</name></param> + <param><type>uint32_t</type> <name>groupCountZ</name></param> </command> <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary" pipeline="compute"> <proto><type>void</type> <name>vkCmdDispatchIndirect</name></proto> @@ -4030,12 +4503,96 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <param optional="false,true"><type>uint32_t</type>* <name>pPropertyCount</name></param> <param optional="true" len="pPropertyCount"><type>VkSparseImageFormatProperties2KHR</type>* <name>pProperties</name></param> </command> + <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary"> + <proto><type>void</type> <name>vkCmdPushDescriptorSetKHR</name></proto> + <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param> + <param><type>VkPipelineBindPoint</type> <name>pipelineBindPoint</name></param> + <param><type>VkPipelineLayout</type> <name>layout</name></param> + <param><type>uint32_t</type> <name>set</name></param> + <param><type>uint32_t</type> <name>descriptorWriteCount</name></param> + <param len="descriptorWriteCount">const <type>VkWriteDescriptorSet</type>* <name>pDescriptorWrites</name></param> + </command> <command> <proto><type>void</type> <name>vkTrimCommandPoolKHR</name></proto> <param><type>VkDevice</type> <name>device</name></param> <param externsync="true"><type>VkCommandPool</type> <name>commandPool</name></param> <param optional="true"><type>VkCommandPoolTrimFlagsKHR</type> <name>flags</name></param> </command> + <command> + <proto><type>void</type> <name>vkGetPhysicalDeviceProperties2KHX</name></proto> + <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> + <param><type>VkPhysicalDeviceProperties2KHX</type>* <name>pProperties</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FORMAT_NOT_SUPPORTED"> + <proto><type>VkResult</type> <name>vkGetPhysicalDeviceImageFormatProperties2KHX</name></proto> + <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> + <param>const <type>VkPhysicalDeviceImageFormatInfo2KHX</type>* <name>pImageFormatInfo</name></param> + <param><type>VkImageFormatProperties2KHX</type>* <name>pImageFormatProperties</name></param> + </command> + <command> + <proto><type>void</type> <name>vkGetPhysicalDeviceExternalBufferPropertiesKHX</name></proto> + <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> + <param>const <type>VkPhysicalDeviceExternalBufferInfoKHX</type>* <name>pExternalBufferInfo</name></param> + <param><type>VkExternalBufferPropertiesKHX</type>* <name>pExternalBufferProperties</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY"> + <proto><type>VkResult</type> <name>vkGetMemoryWin32HandleKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>VkDeviceMemory</type> <name>memory</name></param> + <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param> + <param><type>HANDLE</type>* <name>pHandle</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX"> + <proto><type>VkResult</type> <name>vkGetMemoryWin32HandlePropertiesKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param> + <param><type>HANDLE</type> <name>handle</name></param> + <param><type>VkMemoryWin32HandlePropertiesKHX</type>* <name>pMemoryWin32HandleProperties</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY"> + <proto><type>VkResult</type> <name>vkGetMemoryFdKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>VkDeviceMemory</type> <name>memory</name></param> + <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param> + <param><type>int</type>* <name>pFd</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX"> + <proto><type>VkResult</type> <name>vkGetMemoryFdPropertiesKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param> + <param><type>int</type> <name>fd</name></param> + <param><type>VkMemoryFdPropertiesKHX</type>* <name>pMemoryFdProperties</name></param> + </command> + <command> + <proto><type>void</type> <name>vkGetPhysicalDeviceExternalSemaphorePropertiesKHX</name></proto> + <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> + <param>const <type>VkPhysicalDeviceExternalSemaphoreInfoKHX</type>* <name>pExternalSemaphoreInfo</name></param> + <param><type>VkExternalSemaphorePropertiesKHX</type>* <name>pExternalSemaphoreProperties</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY"> + <proto><type>VkResult</type> <name>vkGetSemaphoreWin32HandleKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>VkSemaphore</type> <name>semaphore</name></param> + <param><type>VkExternalSemaphoreHandleTypeFlagBitsKHX</type> <name>handleType</name></param> + <param><type>HANDLE</type>* <name>pHandle</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX"> + <proto><type>VkResult</type> <name>vkImportSemaphoreWin32HandleKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkImportSemaphoreWin32HandleInfoKHX</type>* <name>pImportSemaphoreWin32HandleInfo</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY"> + <proto><type>VkResult</type> <name>vkGetSemaphoreFdKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>VkSemaphore</type> <name>semaphore</name></param> + <param><type>VkExternalSemaphoreHandleTypeFlagBitsKHX</type> <name>handleType</name></param> + <param><type>int</type>* <name>pFd</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX"> + <proto><type>VkResult</type> <name>vkImportSemaphoreFdKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkImportSemaphoreFdInfoKHX</type>* <name>pImportSemaphoreFdInfo</name></param> + </command> <command successcodes="VK_SUCCESS"> <proto><type>VkResult</type> <name>vkReleaseDisplayEXT</name></proto> <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> @@ -4088,6 +4645,134 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <param><type>VkSurfaceKHR</type> <name>surface</name></param> <param><type>VkSurfaceCapabilities2EXT</type>* <name>pSurfaceCapabilities</name></param> </command> + <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INITIALIZATION_FAILED"> + <proto><type>VkResult</type> <name>vkEnumeratePhysicalDeviceGroupsKHX</name></proto> + <param><type>VkInstance</type> <name>instance</name></param> + <param optional="false,true"><type>uint32_t</type>* <name>pPhysicalDeviceGroupCount</name></param> + <param optional="true" len="pPhysicalDeviceGroupCount"><type>VkPhysicalDeviceGroupPropertiesKHX</type>* <name>pPhysicalDeviceGroupProperties</name></param> + </command> + <command> + <proto><type>void</type> <name>vkGetDeviceGroupPeerMemoryFeaturesKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>uint32_t</type> <name>heapIndex</name></param> + <param><type>uint32_t</type> <name>localDeviceIndex</name></param> + <param><type>uint32_t</type> <name>remoteDeviceIndex</name></param> + <param><type>VkPeerMemoryFeatureFlagsKHX</type>* <name>pPeerMemoryFeatures</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY"> + <proto><type>VkResult</type> <name>vkBindBufferMemory2KHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>uint32_t</type> <name>bindInfoCount</name></param> + <param len="bindInfoCount">const <type>VkBindBufferMemoryInfoKHX</type>* <name>pBindInfos</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY"> + <proto><type>VkResult</type> <name>vkBindImageMemory2KHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>uint32_t</type> <name>bindInfoCount</name></param> + <param len="bindInfoCount">const <type>VkBindImageMemoryInfoKHX</type>* <name>pBindInfos</name></param> + </command> + <command queues="graphics,compute,transfer" renderpass="both" cmdbufferlevel="primary,secondary"> + <proto><type>void</type> <name>vkCmdSetDeviceMaskKHX</name></proto> + <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param> + <param><type>uint32_t</type> <name>deviceMask</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY"> + <proto><type>VkResult</type> <name>vkGetDeviceGroupPresentCapabilitiesKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>VkDeviceGroupPresentCapabilitiesKHX</type>* <name>pDeviceGroupPresentCapabilities</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR"> + <proto><type>VkResult</type> <name>vkGetDeviceGroupSurfacePresentModesKHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param externsync="true"><type>VkSurfaceKHR</type> <name>surface</name></param> + <param><type>VkDeviceGroupPresentModeFlagsKHX</type>* <name>pModes</name></param> + </command> + <command successcodes="VK_SUCCESS,VK_TIMEOUT,VK_NOT_READY,VK_SUBOPTIMAL_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR"> + <proto><type>VkResult</type> <name>vkAcquireNextImage2KHX</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkAcquireNextImageInfoKHX</type>* <name>pAcquireInfo</name></param> + <param><type>uint32_t</type>* <name>pImageIndex</name></param> + </command> + <command queues="compute" renderpass="outside" cmdbufferlevel="primary,secondary"> + <proto><type>void</type> <name>vkCmdDispatchBaseKHX</name></proto> + <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param> + <param><type>uint32_t</type> <name>baseGroupX</name></param> + <param><type>uint32_t</type> <name>baseGroupY</name></param> + <param><type>uint32_t</type> <name>baseGroupZ</name></param> + <param><type>uint32_t</type> <name>groupCountX</name></param> + <param><type>uint32_t</type> <name>groupCountY</name></param> + <param><type>uint32_t</type> <name>groupCountZ</name></param> + </command> + <command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY"> + <proto><type>VkResult</type> <name>vkGetPhysicalDevicePresentRectanglesKHX</name></proto> + <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> + <param externsync="true"><type>VkSurfaceKHR</type> <name>surface</name></param> + <param optional="false,true"><type>uint32_t</type>* <name>pRectCount</name></param> + <param optional="true" len="pRectCount"><type>VkRect2D</type>* <name>pRects</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY"> + <proto><type>VkResult</type> <name>vkCreateDescriptorUpdateTemplateKHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkDescriptorUpdateTemplateCreateInfoKHR</type>* <name>pCreateInfo</name></param> + <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param> + <param><type>VkDescriptorUpdateTemplateKHR</type>* <name>pDescriptorUpdateTemplate</name></param> + </command> + <command> + <proto><type>void</type> <name>vkDestroyDescriptorUpdateTemplateKHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param optional="true" externsync="true"><type>VkDescriptorUpdateTemplateKHR</type> <name>descriptorUpdateTemplate</name></param> + <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param> + </command> + <command> + <proto><type>void</type> <name>vkUpdateDescriptorSetWithTemplateKHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param externsync="true"><type>VkDescriptorSet</type> <name>descriptorSet</name></param> + <param><type>VkDescriptorUpdateTemplateKHR</type> <name>descriptorUpdateTemplate</name></param> + <param>const <type>void</type>* <name>pData</name></param> + </command> + <command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary"> + <proto><type>void</type> <name>vkCmdPushDescriptorSetWithTemplateKHR</name></proto> + <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param> + <param><type>VkDescriptorUpdateTemplateKHR</type> <name>descriptorUpdateTemplate</name></param> + <param><type>VkPipelineLayout</type> <name>layout</name></param> + <param><type>uint32_t</type> <name>set</name></param> + <param>const <type>void</type>* <name>pData</name></param> + </command> + <command> + <proto><type>void</type> <name>vkSetSMPTE2086MetadataEXT</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param><type>uint32_t</type> <name>swapchainCount</name></param> <!-- Number of swap chains to update in this call --> + <param len="swapchainCount">const <type>VkSwapchainKHR</type>* <name>pSwapchains</name></param> <!-- Swapchains to present an image from --> + <param len="swapchainCount">const <type>VkSMPTE2086MetadataEXT</type>* <name>pMetadata</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"> + <proto><type>VkResult</type> <name>vkCreateIOSSurfaceMVK</name></proto> + <param><type>VkInstance</type> <name>instance</name></param> + <param>const <type>VkIOSSurfaceCreateInfoMVK</type>* <name>pCreateInfo</name></param> + <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param> + <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param> + </command> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"> + <proto><type>VkResult</type> <name>vkCreateMacOSSurfaceMVK</name></proto> + <param><type>VkInstance</type> <name>instance</name></param> + <param>const <type>VkMacOSSurfaceCreateInfoMVK</type>* <name>pCreateInfo</name></param> + <param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param> + <param><type>VkSurfaceKHR</type>* <name>pSurface</name></param> + </command> + <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary"> + <proto><type>void</type> <name>vkCmdSetViewportWScalingNV</name></proto> + <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param> + <param><type>uint32_t</type> <name>firstViewport</name></param> + <param><type>uint32_t</type> <name>viewportCount</name></param> + <param len="viewportCount" noautovalidity="true">const <type>VkViewportWScalingNV</type>* <name>pViewportWScalings</name></param> + </command> + <command queues="graphics" renderpass="both" cmdbufferlevel="primary,secondary"> + <proto><type>void</type> <name>vkCmdSetDiscardRectangleEXT</name></proto> + <param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param> + <param><type>uint32_t</type> <name>firstDiscardRectangle</name></param> + <param><type>uint32_t</type> <name>discardRectangleCount</name></param> + <param len="discardRectangleCount">const <type>VkRect2D</type>* <name>pDiscardRectangles</name></param> + </command> </commands> <!-- SECTION: Vulkan API interface definitions --> @@ -4460,7 +5145,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </extension> <extension name="VK_EXT_debug_report" number="12" type="instance" author="Google, Inc." contact="Courtney Goeltzenleuchter @courtney" supported="vulkan"> <require> - <enum value="4" name="VK_EXT_DEBUG_REPORT_SPEC_VERSION"/> + <enum value="5" name="VK_EXT_DEBUG_REPORT_SPEC_VERSION"/> <enum value=""VK_EXT_debug_report"" name="VK_EXT_DEBUG_REPORT_EXTENSION_NAME"/> <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"/> <enum offset="1" dir="-" extends="VkResult" name="VK_ERROR_VALIDATION_FAILED_EXT"/> @@ -4540,13 +5225,14 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_AMD_shader_explicit_vertex_parameter"" name="VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_EXT_debug_marker" number="23" type="device" author="Baldur Karlsson" contact="[email protected]" supported="vulkan"> + <extension name="VK_EXT_debug_marker" number="23" type="device" requires="VK_EXT_debug_report" author="Baldur Karlsson" contact="[email protected]" supported="vulkan"> <require> - <enum value="3" name="VK_EXT_DEBUG_MARKER_SPEC_VERSION"/> + <enum value="4" name="VK_EXT_DEBUG_MARKER_SPEC_VERSION"/> <enum value=""VK_EXT_debug_marker"" name="VK_EXT_DEBUG_MARKER_EXTENSION_NAME"/> <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT"/> <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT"/> <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT"/> + <type name="VkDebugReportObjectTypeEXT"/> <type name="VkDebugMarkerObjectNameInfoEXT"/> <type name="VkDebugMarkerObjectTagInfoEXT"/> <type name="VkDebugMarkerMarkerInfoEXT"/> @@ -4745,10 +5431,17 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_NV_extension_53"" name="VK_NV_EXTENSION_53_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_54" number="54" author="NVIDIA" contact="Jeff Bolz @jbolz" supported="disabled"> + <extension name="VK_KHX_multiview" number="54" type="device" author="NVIDIA" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> - <enum value="0" name="VK_NV_EXTENSION_54_SPEC_VERSION"/> - <enum value=""VK_NV_extension_54"" name="VK_NV_EXTENSION_54_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_MULTIVIEW_SPEC_VERSION"/> + <enum value=""VK_KHX_multiview"" name="VK_KHX_MULTIVIEW_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX"/> + <enum bitpos="1" extends="VkDependencyFlagBits" name="VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX"/> + <type name="VkRenderPassMultiviewCreateInfoKHX"/> + <type name="VkPhysicalDeviceMultiviewFeaturesKHX"/> + <type name="VkPhysicalDeviceMultiviewPropertiesKHX"/> </require> </extension> <extension name="VK_IMG_format_pvrtc" number="55" type="device" author="IMG" contact="Tobias Hector @tobias" supported="vulkan"> @@ -4806,7 +5499,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkWin32KeyedMutexAcquireReleaseInfoNV"/> </require> </extension> - <extension name="VK_KHR_get_physical_device_properties2" number="60" author="KHR" contact="Jeff Bolz @jbolz" supported="vulkan"> + <extension name="VK_KHR_get_physical_device_properties2" number="60" type="instance" author="KHR" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> <enum value="1" name="VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION"/> <enum value=""VK_KHR_get_physical_device_properties2"" name="VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME"/> @@ -4837,10 +5530,56 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkGetPhysicalDeviceSparseImageFormatProperties2KHR"/> </require> </extension> - <extension name="VK_KHR_extension_61" number="61" author="KHR" contact="Jeff Bolz @jbolz" supported="disabled"> + <extension name="VK_KHX_device_group" number="61" type="device" author="KHX" requires="VK_KHR_swapchain" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_61_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_61"" name="VK_KHR_EXTENSION_61_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_DEVICE_GROUP_SPEC_VERSION"/> + <enum value=""VK_KHX_device_group"" name="VK_KHX_DEVICE_GROUP_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX"/> + <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX"/> + <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX"/> + <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX"/> + <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX"/> + <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX"/> + <enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX"/> + <enum offset="9" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX"/> + <enum offset="10" extends="VkStructureType" name="VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX"/> + <enum offset="11" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX"/> + <enum offset="12" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX"/> + <type name="VkPeerMemoryFeatureFlagsKHX"/> + <type name="VkPeerMemoryFeatureFlagBitsKHX"/> + <type name="VkMemoryAllocateFlagsKHX"/> + <type name="VkMemoryAllocateFlagBitsKHX"/> + <type name="VkDeviceGroupPresentModeFlagBitsKHX"/> + <type name="VkDeviceGroupPresentModeFlagsKHX"/> + <type name="VkMemoryAllocateFlagsInfoKHX"/> + <type name="VkBindBufferMemoryInfoKHX"/> + <type name="VkBindImageMemoryInfoKHX"/> + <type name="VkDeviceGroupRenderPassBeginInfoKHX"/> + <type name="VkDeviceGroupCommandBufferBeginInfoKHX"/> + <type name="VkDeviceGroupSubmitInfoKHX"/> + <type name="VkDeviceGroupBindSparseInfoKHX"/> + <type name="VkDeviceGroupPresentCapabilitiesKHX"/> + <type name="VkImageSwapchainCreateInfoKHX"/> + <type name="VkBindImageMemorySwapchainInfoKHX"/> + <type name="VkAcquireNextImageInfoKHX"/> + <type name="VkDeviceGroupPresentInfoKHX"/> + <type name="VkDeviceGroupSwapchainCreateInfoKHX"/> + <command name="vkGetDeviceGroupPeerMemoryFeaturesKHX"/> + <command name="vkBindBufferMemory2KHX"/> + <command name="vkBindImageMemory2KHX"/> + <command name="vkCmdSetDeviceMaskKHX"/> + <command name="vkGetDeviceGroupPresentCapabilitiesKHX"/> + <command name="vkGetDeviceGroupSurfacePresentModesKHX"/> + <command name="vkAcquireNextImage2KHX"/> + <command name="vkCmdDispatchBaseKHX"/> + <command name="vkGetPhysicalDevicePresentRectanglesKHX"/> + <enum bitpos="6" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_BIND_SFR_BIT_KHX" comment="Allows using VkBindImageMemoryInfoKHX::pSFRRects when binding memory to the image"/> + <enum bitpos="3" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX"/> + <enum bitpos="4" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_DISPATCH_BASE_KHX"/> + <enum bitpos="2" extends="VkDependencyFlagBits" name="VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX" comment="Dependency is across devices"/> + <enum bitpos="0" extends="VkSwapchainCreateFlagBitsKHR" name="VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX" comment="Allow images with VK_IMAGE_CREATE_BIND_SFR_BIT_KHX"/> </require> </extension> <extension name="VK_EXT_validation_flags" number="62" type="instance" author="Google, Inc." contact="Tobin Ehlis @tobine" supported="vulkan"> @@ -4851,7 +5590,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkValidationFlagsEXT"/> </require> </extension> - <extension name="VK_NN_vi_surface" number="63" author="NN" contact="Mathias Heyer @mheyer" type="instance" requires="VK_KHR_surface" protect="VK_USE_PLATFORM_VI_NN" supported="vulkan"> + <extension name="VK_NN_vi_surface" number="63" type="instance" author="NN" contact="Mathias Heyer @mheyer" requires="VK_KHR_surface" protect="VK_USE_PLATFORM_VI_NN" supported="vulkan"> <require> <enum value="1" name="VK_NN_VI_SURFACE_SPEC_VERSION"/> <enum value=""VK_NN_vi_surface"" name="VK_NN_VI_SURFACE_EXTENSION_NAME"/> @@ -4867,13 +5606,13 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_KHR_shader_draw_parameters"" name="VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_EXT_shader_subgroup_ballot" number="65" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> + <extension name="VK_EXT_shader_subgroup_ballot" number="65" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> <require> <enum value="1" name="VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION"/> <enum value=""VK_EXT_shader_subgroup_ballot"" name="VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_EXT_shader_subgroup_vote" number="66" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> + <extension name="VK_EXT_shader_subgroup_vote" number="66" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> <require> <enum value="1" name="VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION"/> <enum value=""VK_EXT_shader_subgroup_vote"" name="VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME"/> @@ -4897,7 +5636,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_IMG_extension_69"" name="VK_IMG_EXTENSION_69_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_KHR_maintenance1" number="70" author="KHR" contact="Piers Daniell @pdaniell" supported="vulkan"> + <extension name="VK_KHR_maintenance1" number="70" type="device" author="KHR" contact="Piers Daniell @pdaniell" supported="vulkan"> <require> <enum value="1" name="VK_KHR_MAINTENANCE1_SPEC_VERSION"/> <enum value=""VK_KHR_maintenance1"" name="VK_KHR_MAINTENANCE1_EXTENSION_NAME"/> @@ -4908,70 +5647,157 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkTrimCommandPoolKHR"/> </require> </extension> - <extension name="VK_KHR_extension_71" number="71" author="KHR" contact="Jeff Bolz @jbolz" supported="disabled"> + <extension name="VK_KHX_device_group_creation" number="71" type="instance" author="KHX" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_71_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_71"" name="VK_KHR_EXTENSION_71_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION"/> + <enum value=""VK_KHX_device_group_creation"" name="VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX"/> + <enum name="VK_MAX_DEVICE_GROUP_SIZE_KHX"/> + <type name="VkPhysicalDeviceGroupPropertiesKHX"/> + <type name="VkDeviceGroupDeviceCreateInfoKHX"/> + <command name="vkEnumeratePhysicalDeviceGroupsKHX"/> + <enum bitpos="1" extends="VkMemoryHeapFlagBits" name="VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX" comment="If set, heap allocations allocate multiple instances by default"/> </require> </extension> - <extension name="VK_KHR_extension_72" number="72" author="KHR" contact="James Jones @cubanismo" supported="disable"> + <extension name="VK_KHX_external_memory_capabilities" number="72" type="instance" author="KHX" requires="VK_KHR_get_physical_device_properties2" contact="James Jones @cubanismo" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_72_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_72"" name="VK_KHR_EXTENSION_72_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION"/> + <enum value=""VK_KHX_external_memory_capabilities"" name="VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX"/> + <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX"/> + <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX"/> + <enum offset="5" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX"/> <!-- KHX-only. Remove for KHR --> + <enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX"/> <!-- KHX-only. Remove for KHR --> + <enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX"/> <!-- KHX-only. Remove for KHR --> + <enum name="VK_LUID_SIZE_KHX"/> + <type name="VkExternalMemoryHandleTypeFlagsKHX"/> + <type name="VkExternalMemoryHandleTypeFlagBitsKHX"/> + <type name="VkExternalMemoryFeatureFlagsKHX"/> + <type name="VkExternalMemoryFeatureFlagBitsKHX"/> + <type name="VkExternalMemoryPropertiesKHX"/> + <type name="VkPhysicalDeviceExternalImageFormatInfoKHX"/> + <type name="VkExternalImageFormatPropertiesKHX"/> + <type name="VkPhysicalDeviceExternalBufferInfoKHX"/> + <type name="VkExternalBufferPropertiesKHX"/> + <type name="VkPhysicalDeviceIDPropertiesKHX"/> + <type name="VkPhysicalDeviceProperties2KHX"/> <!-- KHX-only. Remove for KHR --> + <type name="VkImageFormatProperties2KHX"/> <!-- KHX-only. Remove for KHR --> + <type name="VkPhysicalDeviceImageFormatInfo2KHX"/> <!-- KHX-only. Remove for KHR --> + <command name="vkGetPhysicalDeviceExternalBufferPropertiesKHX"/> + <command name="vkGetPhysicalDeviceProperties2KHX"/> <!-- KHX-only. Remove for KHR --> + <command name="vkGetPhysicalDeviceImageFormatProperties2KHX"/> <!-- KHX-only. Remove for KHR --> </require> </extension> - <extension name="VK_KHR_extension_73" number="73" author="KHR" contact="James Jones @cubanismo" supported="disable"> + <extension name="VK_KHX_external_memory" number="73" type="device" requires="VK_KHX_external_memory_capabilities" author="KHX" contact="James Jones @cubanismo" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_73_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_73"" name="VK_KHR_EXTENSION_73_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_EXTERNAL_MEMORY_SPEC_VERSION"/> + <enum value=""VK_KHX_external_memory"" name="VK_KHX_EXTERNAL_MEMORY_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX"/> + <enum offset="3" dir="-" extends="VkResult" name="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX"/> + <enum name="VK_QUEUE_FAMILY_EXTERNAL_KHX"/> + <type name="VkExternalMemoryImageCreateInfoKHX"/> + <type name="VkExternalMemoryBufferCreateInfoKHX"/> + <type name="VkExportMemoryAllocateInfoKHX"/> </require> </extension> - <extension name="VK_KHR_extension_74" number="74" author="KHR" contact="James Jones @cubanismo" supported="disable"> + <extension name="VK_KHX_external_memory_win32" number="74" type="device" requires="VK_KHX_external_memory_capabilities,VK_KHX_external_memory" author="KHX" contact="James Jones @cubanismo" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_74_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_74"" name="VK_KHR_EXTENSION_74_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_EXTERNAL_MEMORY_WIN32_SPEC_VERSION"/> + <enum value=""VK_KHX_external_memory_win32"" name="VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX"/> + <type name="VkImportMemoryWin32HandleInfoKHX"/> + <type name="VkExportMemoryWin32HandleInfoKHX"/> + <type name="VkMemoryWin32HandlePropertiesKHX"/> + <command name="vkGetMemoryWin32HandleKHX"/> + <command name="vkGetMemoryWin32HandlePropertiesKHX"/> </require> </extension> - <extension name="VK_KHR_extension_75" number="75" author="KHR" contact="James Jones @cubanismo" supported="disable"> + <extension name="VK_KHX_external_memory_fd" number="75" type="device" requires="VK_KHX_external_memory_capabilities,VK_KHX_external_memory" author="KHX" contact="James Jones @cubanismo" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_75_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_75"" name="VK_KHR_EXTENSION_75_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_EXTERNAL_MEMORY_FD_SPEC_VERSION"/> + <enum value=""VK_KHX_external_memory_fd"" name="VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX"/> + <type name="VkImportMemoryFdInfoKHX"/> + <type name="VkMemoryFdPropertiesKHX"/> + <command name="vkGetMemoryFdKHX"/> + <command name="vkGetMemoryFdPropertiesKHX"/> </require> </extension> - <extension name="VK_KHR_extension_76" number="76" author="KHR" contact="James Jones @cubanismo" supported="disable"> + <extension name="VK_KHX_win32_keyed_mutex" number="76" type="device" requires="VK_KHX_external_memory_capabilities,VK_KHX_external_memory,VK_KHX_external_memory_win32" author="KHX" contact="Carsten Rohde" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_76_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_76"" name="VK_KHR_EXTENSION_76_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_WIN32_KEYED_MUTEX_SPEC_VERSION"/> + <enum value=""VK_KHX_win32_keyed_mutex"" name="VK_KHX_WIN32_KEYED_MUTEX_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX"/> + <type name="VkWin32KeyedMutexAcquireReleaseInfoKHX"/> </require> </extension> - <extension name="VK_KHR_extension_77" number="77" author="KHR" contact="James Jones @cubanismo" supported="disable"> + <extension name="VK_KHX_external_semaphore_capabilities" number="77" type="instance" author="KHX" requires="VK_KHR_get_physical_device_properties2" contact="James Jones @cubanismo" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_77_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_77"" name="VK_KHR_EXTENSION_77_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION"/> + <enum value=""VK_KHX_external_semaphore_capabilities"" name="VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX"/> + <enum name="VK_LUID_SIZE_KHX"/> + <type name="VkExternalSemaphoreHandleTypeFlagsKHX"/> + <type name="VkExternalSemaphoreHandleTypeFlagBitsKHX"/> + <type name="VkExternalSemaphoreFeatureFlagsKHX"/> + <type name="VkExternalSemaphoreFeatureFlagBitsKHX"/> + <type name="VkPhysicalDeviceExternalSemaphoreInfoKHX"/> + <type name="VkExternalSemaphorePropertiesKHX"/> + <type name="VkPhysicalDeviceIDPropertiesKHX"/> + <type name="VkPhysicalDeviceProperties2KHX"/> <!-- KHX-only. Remove for KHR --> + <command name="vkGetPhysicalDeviceExternalSemaphorePropertiesKHX"/> + <command name="vkGetPhysicalDeviceProperties2KHX"/> <!-- KHX-only. Remove for KHR --> </require> </extension> - <extension name="VK_KHR_extension_78" number="78" author="KHR" contact="James Jones @cubanismo" supported="disable"> + <extension name="VK_KHX_external_semaphore" number="78" type="device" requires="VK_KHX_external_semaphore_capabilities" author="KHX" contact="James Jones @cubanismo" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_78_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_78"" name="VK_KHR_EXTENSION_78_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_EXTERNAL_SEMAPHORE_SPEC_VERSION"/> + <enum value=""VK_KHX_external_semaphore"" name="VK_KHX_EXTERNAL_SEMAPHORE_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX"/> + <type name="VkExportSemaphoreCreateInfoKHX"/> </require> </extension> - <extension name="VK_KHR_extension_79" number="79" author="KHR" contact="James Jones @cubanismo" supported="disable"> + <extension name="VK_KHX_external_semaphore_win32" number="79" type="device" requires="VK_KHX_external_semaphore_capabilities,VK_KHX_external_semaphore" author="KHX" contact="James Jones @cubanismo" protect="VK_USE_PLATFORM_WIN32_KHX" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_79_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_79"" name="VK_KHR_EXTENSION_79_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION"/> + <enum value=""VK_KHX_external_semaphore_win32"" name="VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX"/> + <type name="VkImportSemaphoreWin32HandleInfoKHX"/> + <type name="VkExportSemaphoreWin32HandleInfoKHX"/> + <type name="VkD3D12FenceSubmitInfoKHX"/> + <command name="vkImportSemaphoreWin32HandleKHX"/> + <command name="vkGetSemaphoreWin32HandleKHX"/> </require> </extension> - <extension name="VK_KHR_extension_80" number="80" author="KHR" contact="James Jones @cubanismo" supported="disable"> + <extension name="VK_KHX_external_semaphore_fd" number="80" type="device" requires="VK_KHX_external_semaphore_capabilities,VK_KHX_external_semaphore" author="KHX" contact="James Jones @cubanismo" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_80_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_80"" name="VK_KHR_EXTENSION_80_EXTENSION_NAME"/> + <enum value="1" name="VK_KHX_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION"/> + <enum value=""VK_KHX_external_semaphore_fd"" name="VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX"/> + <type name="VkImportSemaphoreFdInfoKHX"/> + <command name="vkImportSemaphoreFdKHX"/> + <command name="vkGetSemaphoreFdKHX"/> </require> </extension> - <extension name="VK_KHR_extension_81" number="81" author="KHR" contact="Jeff Bolz @jbolz" supported="disabled"> + <extension name="VK_KHR_push_descriptor" number="81" type="device" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_81_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_81"" name="VK_KHR_EXTENSION_81_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION"/> + <enum value=""VK_KHR_push_descriptor"" name="VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"/> + <enum bitpos="0" extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR" comment="Descriptors are pushed via flink:vkCmdPushDescriptorSetKHR"/> + <command name="vkCmdPushDescriptorSetKHR"/> + <type name="VkPhysicalDevicePushDescriptorPropertiesKHR"/> </require> </extension> <extension name="VK_KHR_extension_82" number="82" author="KHR" contact="Jeff Bolz @jbolz" supported="disabled"> @@ -4998,10 +5824,19 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_KHR_extension_85"" name="VK_KHR_EXTENSION_85_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_KHR_extension_86" number="86" author="KHR" contact="Markus Tavenrath @mtavenrath" supported="disabled"> - <require> - <enum value="0" name="VK_KHR_EXTENSION_86_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_86"" name="VK_KHR_EXTENSION_86_EXTENSION_NAME"/> + <extension name="VK_KHR_descriptor_update_template" number="86" type="device" author="KHR" contact="Markus Tavenrath @mtavenrath" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION"/> + <enum value=""VK_KHR_descriptor_update_template"" name="VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR"/> + <command name="vkCreateDescriptorUpdateTemplateKHR"/> + <command name="vkDestroyDescriptorUpdateTemplateKHR"/> + <command name="vkUpdateDescriptorSetWithTemplateKHR"/> + <command name="vkCmdPushDescriptorSetWithTemplateKHR"/> + <type name="VkDescriptorUpdateTemplateCreateFlagsKHR"/> + <type name="VkDescriptorUpdateTemplateTypeKHR"/> + <type name="VkDescriptorUpdateTemplateEntryKHR"/> + <type name="VkDescriptorUpdateTemplateCreateInfoKHR"/> </require> </extension> <extension name="VK_NVX_device_generated_commands" number="87" type="device" author="NVIDIA" contact="Christoph Kubisch @pixeljetstream" supported="vulkan"> @@ -5050,12 +5885,17 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"/> </require> </extension> - <extension name="VK_KHR_extension_88" number="88" author="NV" contact="Eric Werness @ewerness" supported="disabled"> - <require> - <enum value="0" name="VK_KHR_EXTENSION_88_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_88"" name="VK_KHR_EXTENSION_88_EXTENSION_NAME"/> - </require> - </extension> + <extension name="VK_NV_clip_space_w_scaling" number="88" type="device" author="NV" contact="Eric Werness @ewerness" supported="vulkan"> + <require> + <enum value="1" name="VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION"/> + <enum value=""VK_NV_clip_space_w_scaling"" name="VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"/> + <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV"/> + <type name="VkViewportWScalingNV"/> + <type name="VkPipelineViewportWScalingStateCreateInfoNV"/> + <command name="vkCmdSetViewportWScalingNV"/> + </require> + </extension> <extension name="VK_EXT_direct_mode_display" number="89" type="instance" requires="VK_KHR_display" author="NVIDIA" contact="James Jones @cubanismo" supported="vulkan"> <require> <enum value="1" name="VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION"/> @@ -5115,40 +5955,57 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_KHR_extension_94"" name="VK_KHR_EXTENSION_94_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_95" number="95" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> + <extension name="VK_NV_sample_mask_override_coverage" number="95" type="device" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="vulkan"> <require> - <enum value="0" name="VK_NV_EXTENSION_95_SPEC_VERSION"/> - <enum value=""VK_NV_extension_95"" name="VK_NV_EXTENSION_95_EXTENSION_NAME"/> + <enum value="1" name="VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION"/> + <enum value=""VK_NV_sample_mask_override_coverage"" name="VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_96" number="96" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> + <extension name="VK_NV_geometry_shader_passthrough" number="96" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> <require> - <enum value="0" name="VK_NV_EXTENSION_96_SPEC_VERSION"/> - <enum value=""VK_NV_extension_96"" name="VK_NV_EXTENSION_96_EXTENSION_NAME"/> + <enum value="1" name="VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION"/> + <enum value=""VK_NV_geometry_shader_passthrough"" name="VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_97" number="97" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> + <extension name="VK_NV_viewport_array2" number="97" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> <require> - <enum value="0" name="VK_NV_EXTENSION_97_SPEC_VERSION"/> - <enum value=""VK_NV_extension_97"" name="VK_NV_EXTENSION_97_EXTENSION_NAME"/> + <enum value="1" name="VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION"/> + <enum value=""VK_NV_viewport_array2"" name="VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_98" number="98" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> + <extension name="VK_NVX_multiview_per_view_attributes" number="98" type="device" author="NVIDIA" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> - <enum value="0" name="VK_NV_EXTENSION_98_SPEC_VERSION"/> - <enum value=""VK_NV_extension_98"" name="VK_NV_EXTENSION_98_EXTENSION_NAME"/> + <enum value="1" name="VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION"/> + <enum value=""VK_NVX_multiview_per_view_attributes"" name="VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"/> + <enum bitpos="0" extends="VkSubpassDescriptionFlagBits" name="VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX"/> + <enum bitpos="1" extends="VkSubpassDescriptionFlagBits" name="VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX"/> + <type name="VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"/> </require> </extension> - <extension name="VK_NV_extension_99" number="99" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> + <extension name="VK_NV_viewport_swizzle" number="99" type="device" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="vulkan"> <require> - <enum value="0" name="VK_NV_EXTENSION_99_SPEC_VERSION"/> - <enum value=""VK_NV_extension_99"" name="VK_NV_EXTENSION_99_EXTENSION_NAME"/> + <enum value="1" name="VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION"/> + <enum value=""VK_NV_viewport_swizzle"" name="VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"/> + <type name="VkViewportSwizzleNV"/> + <type name="VkViewportCoordinateSwizzleNV"/> + <type name="VkPipelineViewportSwizzleStateCreateInfoNV"/> + <type name="VkPipelineViewportSwizzleStateCreateFlagsNV"/> </require> </extension> - <extension name="VK_NV_extension_100" number="100" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> + <extension name="VK_EXT_discard_rectangles" number="100" type="device" requires="VK_KHR_get_physical_device_properties2" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="vulkan"> <require> - <enum value="0" name="VK_NV_EXTENSION_100_SPEC_VERSION"/> - <enum value=""VK_NV_extension_100"" name="VK_NV_EXTENSION_100_EXTENSION_NAME"/> + <enum value="1" name="VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION"/> + <enum value=""VK_EXT_discard_rectangles"" name="VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"/> + <enum offset="0" extends="VkDynamicState" name="VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT"/> + <type name="VkPhysicalDeviceDiscardRectanglePropertiesEXT"/> + <type name="VkPipelineDiscardRectangleStateCreateInfoEXT"/> + <type name="VkPipelineDiscardRectangleStateCreateFlagsEXT"/> + <type name="VkDiscardRectangleModeEXT"/> + <command name="vkCmdSetDiscardRectangleEXT"/> </require> </extension> <extension name="VK_NV_extension_101" number="101" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> @@ -5175,10 +6032,10 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_NV_extension_104"" name="VK_NV_EXTENSION_104_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_EXT_swapchain_colorspace" number="105" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtneygo" requires="VK_KHR_surface" supported="vulkan"> + <extension name="VK_EXT_swapchain_colorspace" number="105" type="device" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtneygo" requires="VK_KHR_surface" supported="disabled"> <require> - <enum value="1" name="VK_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION"/> - <enum value=""VK_EXT_swapchain_colorspace"" name="VK_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME"/> + <enum value="1" name="VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION"/> + <enum value=""VK_EXT_swapchain_colorspace"" name="VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME"/> <enum offset="1" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT"/> <enum offset="2" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT"/> <enum offset="3" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_SCRGB_LINEAR_EXT"/> @@ -5188,15 +6045,18 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum offset="7" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_BT709_LINEAR_EXT"/> <enum offset="8" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_BT709_NONLINEAR_EXT"/> <enum offset="9" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_BT2020_LINEAR_EXT"/> - <enum offset="10" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_BT2020_NONLINEAR_EXT"/> + <enum offset="10" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_BT2020_NONLINEAR_EXT"/> <enum offset="11" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT"/> <enum offset="12" extends="VkColorSpaceKHR" name="VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT"/> </require> </extension> - <extension name="VK_EXT_extension_106" number="106" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtneygo" supported="disabled"> + <extension name="VK_EXT_SMPTE2086_metadata" number="106" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtneygo" supported="disabled"> <require> - <enum value="0" name="VK_KHR_EXTENSION_106_SPEC_VERSION"/> - <enum value=""VK_EXT_extension_106"" name="VK_KHR_EXTENSION_106_EXTENSION_NAME"/> + <enum value="0" name="VK_EXT_SMPTE2086_METADATA_SPEC_VERSION"/> + <enum value=""VK_EXT_SMPTE2086_metadata"" name="VK_EXT_SMPTE2086_METADATA_EXTENSION_NAME"/> + <type name="VkSMPTE2086MetadataEXT"/> + <type name="VkXYColorEXT"/> + <command name="vkSetSMPTE2086MetadataEXT"/> </require> </extension> <extension name="VK_IMG_extension_107" number="107" author="IMG" contact="Michael Worcester @michaelworcester" supported="disabled"> @@ -5265,5 +6125,73 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_KHR_extension_117"" name="VK_KHR_EXTENSION_117_EXTENSION_NAME"/> </require> </extension> + <extension name="VK_KHR_extension_118" number="118" author="KHR" contact="Michael Worcester @michaelworcester" supported="disabled"> + <require> + <enum value="0" name="VK_KHR_EXTENSION_118_SPEC_VERSION"/> + <enum value=""VK_KHR_extension_118"" name="VK_KHR_EXTENSION_118_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_KHR_extension_119" number="119" author="KHR" contact="Michael Worcester @michaelworcester" supported="disabled"> + <require> + <enum value="0" name="VK_KHR_EXTENSION_119_SPEC_VERSION"/> + <enum value=""VK_KHR_extension_119"" name="VK_KHR_EXTENSION_119_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_KHR_extension_120" number="120" author="KHR" contact="James Jones @cubanismo" supported="disabled"> + <require> + <enum value="0" name="VK_KHR_EXTENSION_120_SPEC_VERSION"/> + <enum value=""VK_KHR_extension_120"" name="VK_KHR_EXTENSION_120_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_KHR_variable_pointers" number="121" author="KHR" contact="John Kessenich @johnk" supported="disabled"> + <require> + <enum value="0" name="VK_KHR_variable_pointers_SPEC_VERSION"/> + <enum value=""VK_KHR_variable_pointers"" name="VK_KHR_variable_pointers_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_KHR_extension_122" number="122" author="KHR" contact="James Jones @cubanismo" supported="disabled"> + <require> + <enum value="0" name="VK_KHR_EXTENSION_122_SPEC_VERSION"/> + <enum value=""VK_KHR_extension_122"" name="VK_KHR_EXTENSION_122_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_MVK_ios_surface" number="123" type="instance" requires="VK_KHR_surface" protect="VK_USE_PLATFORM_IOS_MVK" supported="vulkan" author="MVK" contact="Bill Hollings @billhollings"> + <require> + <enum value="2" name="VK_MVK_IOS_SURFACE_SPEC_VERSION"/> + <enum value=""VK_MVK_ios_surface"" name="VK_MVK_IOS_SURFACE_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK"/> + <type name="VkIOSSurfaceCreateFlagsMVK"/> + <type name="VkIOSSurfaceCreateInfoMVK"/> + <command name="vkCreateIOSSurfaceMVK"/> + </require> + </extension> + <extension name="VK_MVK_macos_surface" number="124" type="instance" requires="VK_KHR_surface" protect="VK_USE_PLATFORM_MACOS_MVK" supported="vulkan" author="MVK" contact="Bill Hollings @billhollings"> + <require> + <enum value="2" name="VK_MVK_MACOS_SURFACE_SPEC_VERSION"/> + <enum value=""VK_MVK_macos_surface"" name="VK_MVK_MACOS_SURFACE_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK"/> + <type name="VkMacOSSurfaceCreateFlagsMVK"/> + <type name="VkMacOSSurfaceCreateInfoMVK"/> + <command name="vkCreateMacOSSurfaceMVK"/> + </require> + </extension> + <extension name="VK_MVK_moltenvk" number="125" type="instance" author="MVK" contact="Bill Hollings @billhollings" supported="disabled"> + <require> + <enum value="0" name="VK_MVK_MOLTENVK_SPEC_VERSION"/> + <enum value=""VK_MVK_moltenvk"" name="VK_MVK_MOLTENVK_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_MESA_extension_126" number="126" author="MESA" contact="Chad Versace @chadversary" supported="disabled"> + <require> + <enum value="0" name="VK_MESA_EXTENSION_126_SPEC_VERSION"/> + <enum value=""VK_MESA_extension_126"" name="VK_MESA_EXTENSION_126_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_MESA_extension_127" number="127" author="MESA" contact="Chad Versace @chadversary" supported="disabled"> + <require> + <enum value="0" name="VK_MESA_EXTENSION_127_SPEC_VERSION"/> + <enum value=""VK_MESA_extension_127"" name="VK_MESA_EXTENSION_127_EXTENSION_NAME"/> + </require> + </extension> </extensions> </registry> |