diff options
| -rw-r--r-- | include/vulkan/vulkan.h | 1284 | ||||
| -rw-r--r-- | src/intel/vulkan/anv_allocator.c | 6 | ||||
| -rw-r--r-- | src/vulkan/registry/vk.xml | 1208 |
3 files changed, 1710 insertions, 788 deletions
diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 51e5e9e313c..16434fefbe6 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 49 +#define VK_HEADER_VERSION 54 #define VK_NULL_HANDLE 0 @@ -146,7 +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_ERROR_INVALID_EXTERNAL_HANDLE_KHR = -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), @@ -222,6 +222,7 @@ 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_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, 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, @@ -256,28 +257,33 @@ typedef enum VkStructureType { 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_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_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000, VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000, VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, @@ -299,11 +305,34 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = 1000113000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000, VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, 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), @@ -657,6 +686,7 @@ typedef enum VkPolygonMode { VK_POLYGON_MODE_FILL = 0, VK_POLYGON_MODE_LINE = 1, VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), @@ -757,6 +787,52 @@ typedef enum VkBlendOp { VK_BLEND_OP_REVERSE_SUBTRACT = 2, VK_BLEND_OP_MIN = 3, VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), @@ -958,6 +1034,7 @@ typedef enum VkFormatFeatureFlagBits { VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000, VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkFormatFeatureFlagBits; typedef VkFlags VkFormatFeatureFlags; @@ -1235,6 +1312,7 @@ typedef enum VkAccessFlagBits { VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, + VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkAccessFlagBits; typedef VkFlags VkAccessFlags; @@ -3862,7 +3940,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( #define VK_KHR_win32_surface 1 #include <windows.h> -#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5 +#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" typedef VkFlags VkWin32SurfaceCreateFlagsKHR; @@ -4027,6 +4105,377 @@ VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( VkCommandPoolTrimFlagsKHR flags); #endif +#define VK_KHR_external_memory_capabilities 1 +#define VK_LUID_SIZE_KHR 8 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" + + +typedef enum VkExternalMemoryHandleTypeFlagBitsKHR { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsKHR; +typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR; + +typedef enum VkExternalMemoryFeatureFlagBitsKHR { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsKHR; +typedef VkFlags VkExternalMemoryFeatureFlagsKHR; + +typedef struct VkExternalMemoryPropertiesKHR { + VkExternalMemoryFeatureFlagsKHR externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes; +} VkExternalMemoryPropertiesKHR; + +typedef struct VkPhysicalDeviceExternalImageFormatInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalImageFormatInfoKHR; + +typedef struct VkExternalImageFormatPropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalMemoryPropertiesKHR externalMemoryProperties; +} VkExternalImageFormatPropertiesKHR; + +typedef struct VkPhysicalDeviceExternalBufferInfoKHR { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalBufferInfoKHR; + +typedef struct VkExternalBufferPropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalMemoryPropertiesKHR externalMemoryProperties; +} VkExternalBufferPropertiesKHR; + +typedef struct VkPhysicalDeviceIDPropertiesKHR { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE_KHR]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDPropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, + VkExternalBufferPropertiesKHR* pExternalBufferProperties); +#endif + +#define VK_KHR_external_memory 1 +#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" +#define VK_QUEUE_FAMILY_EXTERNAL_KHR (~0U-1) + +typedef struct VkExternalMemoryImageCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHR handleTypes; +} VkExternalMemoryImageCreateInfoKHR; + +typedef struct VkExternalMemoryBufferCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHR handleTypes; +} VkExternalMemoryBufferCreateInfoKHR; + +typedef struct VkExportMemoryAllocateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHR handleTypes; +} VkExportMemoryAllocateInfoKHR; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_external_memory_win32 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" + +typedef struct VkImportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; +} VkImportMemoryWin32HandleInfoKHR; + +typedef struct VkExportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHR; + +typedef struct VkMemoryWin32HandlePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryWin32HandlePropertiesKHR; + +typedef struct VkMemoryGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkMemoryGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_memory_fd 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" + +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkMemoryGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); +#endif + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_win32_keyed_mutex 1 +#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" + +typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { + 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; +} VkWin32KeyedMutexAcquireReleaseInfoKHR; + + +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_semaphore_capabilities 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" + + +typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHR { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalSemaphoreHandleTypeFlagBitsKHR; +typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR; + +typedef enum VkExternalSemaphoreFeatureFlagBitsKHR { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalSemaphoreFeatureFlagBitsKHR; +typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalSemaphoreInfoKHR; + +typedef struct VkExternalSemaphorePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes; + VkExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures; +} VkExternalSemaphorePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); +#endif + +#define VK_KHR_external_semaphore 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" + + +typedef enum VkSemaphoreImportFlagBitsKHR { + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSemaphoreImportFlagBitsKHR; +typedef VkFlags VkSemaphoreImportFlagsKHR; + +typedef struct VkExportSemaphoreCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagsKHR handleTypes; +} VkExportSemaphoreCreateInfoKHR; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_external_semaphore_win32 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" + +typedef struct VkImportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlagsKHR flags; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; +} VkImportSemaphoreWin32HandleInfoKHR; + +typedef struct VkExportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportSemaphoreWin32HandleInfoKHR; + +typedef struct VkD3D12FenceSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; +} VkD3D12FenceSubmitInfoKHR; + +typedef struct VkSemaphoreGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +} VkSemaphoreGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_semaphore_fd 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" + +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlagsKHR flags; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +} VkSemaphoreGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); +#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" @@ -4050,6 +4499,21 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( const VkWriteDescriptorSet* pDescriptorWrites); #endif +#define VK_KHR_16bit_storage 1 +#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" + +typedef struct VkPhysicalDevice16BitStorageFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeaturesKHR; + + + #define VK_KHR_incremental_present 1 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" @@ -4165,6 +4629,151 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( VkSwapchainKHR swapchain); #endif +#define VK_KHR_external_fence_capabilities 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" + + +typedef enum VkExternalFenceHandleTypeFlagBitsKHR { + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000008, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalFenceHandleTypeFlagBitsKHR; +typedef VkFlags VkExternalFenceHandleTypeFlagsKHR; + +typedef enum VkExternalFenceFeatureFlagBitsKHR { + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalFenceFeatureFlagBitsKHR; +typedef VkFlags VkExternalFenceFeatureFlagsKHR; + +typedef struct VkPhysicalDeviceExternalFenceInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalFenceInfoKHR; + +typedef struct VkExternalFencePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlagsKHR compatibleHandleTypes; + VkExternalFenceFeatureFlagsKHR externalFenceFeatures; +} VkExternalFencePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, + VkExternalFencePropertiesKHR* pExternalFenceProperties); +#endif + +#define VK_KHR_external_fence 1 +#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" + + +typedef enum VkFenceImportFlagBitsKHR { + VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkFenceImportFlagBitsKHR; +typedef VkFlags VkFenceImportFlagsKHR; + +typedef struct VkExportFenceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagsKHR handleTypes; +} VkExportFenceCreateInfoKHR; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_external_fence_win32 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" + +typedef struct VkImportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlagsKHR flags; + VkExternalFenceHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; +} VkImportFenceWin32HandleInfoKHR; + +typedef struct VkExportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportFenceWin32HandleInfoKHR; + +typedef struct VkFenceGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBitsKHR handleType; +} VkFenceGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_fence_fd 1 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" + +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlagsKHR flags; + VkExternalFenceHandleTypeFlagBitsKHR handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBitsKHR handleType; +} VkFenceGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + #define VK_KHR_get_surface_capabilities2 1 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" @@ -4204,12 +4813,108 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( VkSurfaceFormat2KHR* pSurfaceFormats); #endif +#define VK_KHR_variable_pointers 1 +#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 +#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" + +typedef struct VkPhysicalDeviceVariablePointerFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointerFeaturesKHR; + + + +#define VK_KHR_dedicated_allocation 1 +#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 1 +#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" + +typedef struct VkMemoryDedicatedRequirementsKHR { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirementsKHR; + +typedef struct VkMemoryDedicatedAllocateInfoKHR { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfoKHR; + + + +#define VK_KHR_storage_buffer_storage_class 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" + + +#define VK_KHR_get_memory_requirements2 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" + +typedef struct VkBufferMemoryRequirementsInfo2KHR { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2KHR; + +typedef struct VkImageMemoryRequirementsInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2KHR; + +typedef struct VkImageSparseMemoryRequirementsInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageSparseMemoryRequirementsInfo2KHR; + +typedef struct VkMemoryRequirements2KHR { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2KHR; + +typedef struct VkSparseImageMemoryRequirements2KHR { + VkStructureType sType; + void* pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} VkSparseImageMemoryRequirements2KHR; + + +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements); +#endif + #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) -#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 6 +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 8 #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 +#define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT typedef enum VkDebugReportObjectTypeEXT { @@ -4241,7 +4946,7 @@ typedef enum VkDebugReportObjectTypeEXT { VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, @@ -4253,15 +4958,6 @@ typedef enum VkDebugReportObjectTypeEXT { VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF } VkDebugReportObjectTypeEXT; -typedef enum VkDebugReportErrorEXT { - VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, - VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, - VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_ERROR_NONE_EXT, - VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT, - VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT - VK_DEBUG_REPORT_ERROR_NONE_EXT + 1), - VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportErrorEXT; - typedef enum VkDebugReportFlagBitsEXT { VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, @@ -4491,6 +5187,18 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" +#define VK_AMD_texture_gather_bias_lod 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" + +typedef struct VkTextureLODGatherFormatPropertiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD; + + + #define VK_KHX_multiview 1 #define VK_KHX_MULTIVIEW_SPEC_VERSION 1 #define VK_KHX_MULTIVIEW_EXTENSION_NAME "VK_KHX_multiview" @@ -4846,9 +5554,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX( typedef enum VkValidationCheckEXT { VK_VALIDATION_CHECK_ALL_EXT = 0, + VK_VALIDATION_CHECK_SHADERS_EXT = 1, VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, - VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, - VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_ALL_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), + VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT, + VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF } VkValidationCheckEXT; @@ -4926,341 +5635,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX( 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 void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHX( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, - VkExternalBufferPropertiesKHX* pExternalBufferProperties); -#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_KHX -#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_KHX */ - -#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) @@ -5270,29 +5644,29 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) typedef enum VkIndirectCommandsTokenTypeNVX { - VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = 0, - VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = 1, - VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = 2, - VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = 3, - VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = 4, - VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = 5, - VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = 6, - VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = 7, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX + 1), + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1), VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF } VkIndirectCommandsTokenTypeNVX; typedef enum VkObjectEntryTypeNVX { - VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0, - VK_OBJECT_ENTRY_PIPELINE_NVX = 1, - VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2, - VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3, - VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4, - VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX, - VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX, - VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX + 1), + VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0, + VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1, + VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2, + VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3, + VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4, + VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, + VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX, + VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1), VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF } VkObjectEntryTypeNVX; @@ -5919,6 +6293,134 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( #endif #endif /* VK_USE_PLATFORM_MACOS_MVK */ +#define VK_EXT_sampler_filter_minmax 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" + + +typedef enum VkSamplerReductionModeEXT { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, + VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, + VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT, + VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1), + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSamplerReductionModeEXT; + +typedef struct VkSamplerReductionModeCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSamplerReductionModeEXT reductionMode; +} VkSamplerReductionModeCreateInfoEXT; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + + + +#define VK_AMD_gpu_shader_int16 1 +#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1 +#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" + + +#define VK_EXT_blend_operation_advanced 1 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" + + +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT, + VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT, + VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1), + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + +#define VK_NV_fragment_coverage_to_color 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" + +typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; + +typedef struct VkPipelineCoverageToColorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; + + + +#define VK_NV_framebuffer_mixed_samples 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" + + +typedef enum VkCoverageModulationModeNV { + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV, + VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV, + VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1), + VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageModulationModeNV; + +typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; + +typedef struct VkPipelineCoverageModulationStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV; + + + +#define VK_NV_fill_rectangle 1 +#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 +#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" + + #ifdef __cplusplus } #endif diff --git a/src/intel/vulkan/anv_allocator.c b/src/intel/vulkan/anv_allocator.c index d637867ab9a..efaaebcf39c 100644 --- a/src/intel/vulkan/anv_allocator.c +++ b/src/intel/vulkan/anv_allocator.c @@ -1280,14 +1280,14 @@ anv_bo_cache_import(struct anv_device *device, uint32_t gem_handle = anv_gem_fd_to_handle(device, fd); if (!gem_handle) { pthread_mutex_unlock(&cache->mutex); - return vk_error(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX); + return vk_error(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); } struct anv_cached_bo *bo = anv_bo_cache_lookup_locked(cache, gem_handle); if (bo) { if (bo->bo.size != size) { pthread_mutex_unlock(&cache->mutex); - return vk_error(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX); + return vk_error(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); } __sync_fetch_and_add(&bo->refcount, 1); } else { @@ -1303,7 +1303,7 @@ anv_bo_cache_import(struct anv_device *device, if (import_size == (off_t)-1 || import_size != size) { anv_gem_close(device, gem_handle); pthread_mutex_unlock(&cache->mutex); - return vk_error(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX); + return vk_error(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); } bo = vk_alloc(&device->alloc, sizeof(struct anv_cached_bo), 8, diff --git a/src/vulkan/registry/vk.xml b/src/vulkan/registry/vk.xml index 1beed0b7985..a3e142f7bad 100644 --- a/src/vulkan/registry/vk.xml +++ b/src/vulkan/registry/vk.xml @@ -3,24 +3,17 @@ <comment> Copyright (c) 2015-2017 The Khronos Group Inc. -Permission is hereby granted, free of charge, to any person obtaining a -copy of this software and/or associated documentation files (the -"Materials"), to deal in the Materials without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Materials, and to -permit persons to whom the Materials are furnished to do so, subject to -the following conditions: +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at -The above copyright notice and this permission notice shall be included -in all copies or substantial portions of the Materials. + http://www.apache.org/licenses/LICENSE-2.0 -THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. ------------------------------------------------------------------------ @@ -29,8 +22,9 @@ and normative part of the Vulkan Specification, including a canonical machine-readable definition of the API, parameter and member validation language incorporated into the Specification and reference pages, and other material which is registered by Khronos, such as tags used by extension and -layer authors. The only authoritative version of vk.xml is the one -maintained in the master branch of the Khronos Vulkan GitHub project. +layer authors. The authoritative public version of vk.xml is maintained in +the master branch of the Khronos Vulkan GitHub project. The authoritative +private version is maintained in the 1.0 branch of the member gitlab server. </comment> <!-- SECTION: Vulkan vendor IDs for physical devices without PCI vendor IDs --> @@ -112,7 +106,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> 49</type> +#define <name>VK_HEADER_VERSION</name> 54</type> <type category="define"> #define <name>VK_DEFINE_HANDLE</name>(object) typedef struct object##_T* object;</type> @@ -135,6 +129,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type category="basetype">typedef <type>uint32_t</type> <name>VkBool32</name>;</type> <type category="basetype">typedef <type>uint32_t</type> <name>VkFlags</name>;</type> <type category="basetype">typedef <type>uint64_t</type> <name>VkDeviceSize</name>;</type> + <!-- Basic C types, pulled in via vk_platform.h --> <type requires="vk_platform" name="void"/> <type requires="vk_platform" name="char"/> @@ -233,13 +228,19 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <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="VkExternalMemoryHandleTypeFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryHandleTypeFlagsKHR</name>;</type> + <type requires="VkExternalMemoryFeatureFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalMemoryFeatureFlagsKHR</name>;</type> + <type requires="VkExternalSemaphoreHandleTypeFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalSemaphoreHandleTypeFlagsKHR</name>;</type> + <type requires="VkExternalSemaphoreFeatureFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalSemaphoreFeatureFlagsKHR</name>;</type> + <type requires="VkSemaphoreImportFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkSemaphoreImportFlagsKHR</name>;</type> + <type requires="VkExternalFenceHandleTypeFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalFenceHandleTypeFlagsKHR</name>;</type> + <type requires="VkExternalFenceFeatureFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkExternalFenceFeatureFlagsKHR</name>;</type> + <type requires="VkFenceImportFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkFenceImportFlagsKHR</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) --> + <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCoverageToColorStateCreateFlagsNV</name>;</type> <!-- creation flags (no bits yet) --> + <type category="bitmask">typedef <type>VkFlags</type> <name>VkPipelineCoverageModulationStateCreateFlagsNV</name>;</type> <!-- 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> @@ -375,6 +376,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkViewportCoordinateSwizzleNV" category="enum"/> <type name="VkDiscardRectangleModeEXT" category="enum"/> <type name="VkSubpassDescriptionFlagBits" category="enum"/> + <type name="VkCoverageModulationModeNV" category="enum"/> <!-- WSI extensions --> <type name="VkColorSpaceKHR" category="enum"/> <type name="VkCompositeAlphaFlagBitsKHR" category="enum"/> @@ -383,15 +385,18 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkSurfaceTransformFlagBitsKHR" category="enum"/> <type name="VkDebugReportFlagBitsEXT" category="enum"/> <type name="VkDebugReportObjectTypeEXT" category="enum"/> - <type name="VkDebugReportErrorEXT" category="enum"/> <type name="VkRasterizationOrderAMD" category="enum"/> <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="VkExternalMemoryHandleTypeFlagBitsKHR" category="enum"/> + <type name="VkExternalMemoryFeatureFlagBitsKHR" category="enum"/> + <type name="VkExternalSemaphoreHandleTypeFlagBitsKHR" category="enum"/> + <type name="VkExternalSemaphoreFeatureFlagBitsKHR" category="enum"/> + <type name="VkSemaphoreImportFlagBitsKHR" category="enum"/> + <type name="VkExternalFenceHandleTypeFlagBitsKHR" category="enum"/> + <type name="VkExternalFenceFeatureFlagBitsKHR" category="enum"/> + <type name="VkFenceImportFlagBitsKHR" category="enum"/> <type name="VkSurfaceCounterFlagBitsEXT" category="enum"/> <type name="VkDisplayPowerStateEXT" category="enum"/> <type name="VkDeviceEventTypeEXT" category="enum"/> @@ -400,6 +405,8 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkMemoryAllocateFlagBitsKHX" category="enum"/> <type name="VkDeviceGroupPresentModeFlagBitsKHX" category="enum"/> <type name="VkSwapchainCreateFlagBitsKHR" category="enum"/> + <type name="VkSamplerReductionModeEXT" category="enum"/> + <type name="VkBlendOverlapEXT" category="enum"/> <!-- The PFN_vk*Function types are used by VkAllocationCallbacks below --> <type category="funcpointer">typedef void (VKAPI_PTR *<name>PFN_vkInternalAllocationNotification</name>)( @@ -535,7 +542,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,VkPhysicalDeviceMultiviewFeaturesKHX,VkDeviceGroupDeviceCreateInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkPhysicalDeviceFeatures2KHR,VkPhysicalDevice16BitStorageFeaturesKHR,VkPhysicalDeviceVariablePointerFeaturesKHR,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> @@ -547,7 +554,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkInstanceCreateInfo"> <member values="VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkDebugReportCallbackCreateInfoEXT">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkInstanceCreateFlags</type> <name>flags</name></member> <!-- Reserved --> <member optional="true">const <type>VkApplicationInfo</type>* <name>pApplicationInfo</name></member> <member optional="true"><type>uint32_t</type> <name>enabledLayerCount</name></member> @@ -569,7 +576,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,VkMemoryAllocateFlagsInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkDedicatedAllocationMemoryAllocateInfoNV,VkMemoryAllocateFlagsInfoKHX,VkMemoryDedicatedAllocateInfoKHR">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> @@ -955,7 +962,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkPipelineMultisampleStateCreateInfo"> <member values="VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_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="VkPipelineCoverageToColorStateCreateInfoNV,VkPipelineCoverageModulationStateCreateInfoNV">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkPipelineMultisampleStateCreateFlags</type> <name>flags</name></member> <!-- Reserved --> <member><type>VkSampleCountFlagBits</type> <name>rasterizationSamples</name></member> <!-- Number of samples used for rasterization --> <member><type>VkBool32</type> <name>sampleShadingEnable</name></member> <!-- optional (GL45) --> @@ -976,7 +983,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkPipelineColorBlendStateCreateInfo"> <member values="VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_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="VkPipelineColorBlendAdvancedStateCreateInfoEXT">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkPipelineColorBlendStateCreateFlags</type> <name>flags</name></member> <!-- Reserved --> <member><type>VkBool32</type> <name>logicOpEnable</name></member> <member noautovalidity="true"><type>VkLogicOp</type> <name>logicOp</name></member> @@ -1058,7 +1065,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkSamplerCreateInfo"> <member values="VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkSamplerReductionModeCreateInfoEXT">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkSamplerCreateFlags</type> <name>flags</name></member> <!-- Reserved --> <member><type>VkFilter</type> <name>magFilter</name></member> <!-- Filter mode for magnification --> <member><type>VkFilter</type> <name>minFilter</name></member> <!-- Filter mode for minifiation --> @@ -1186,7 +1193,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkFenceCreateInfo"> <member values="VK_STRUCTURE_TYPE_FENCE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkExportFenceCreateInfoKHR,VkExportFenceWin32HandleInfoKHR">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkFenceCreateFlags</type> <name>flags</name></member> <!-- Fence creation flags --> </type> <type category="struct" name="VkPhysicalDeviceFeatures"> @@ -1372,7 +1379,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </type> <type category="struct" name="VkSemaphoreCreateInfo"> <member values="VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO"><type>VkStructureType</type> <name>sType</name></member> - <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkExportSemaphoreCreateInfoKHR,VkExportSemaphoreWin32HandleInfoKHR">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkSemaphoreCreateFlags</type> <name>flags</name></member> <!-- Semaphore creation flags --> </type> <type category="struct" name="VkQueryPoolCreateInfo"> @@ -1414,7 +1421,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 validextensionstructs="VkWin32KeyedMutexAcquireReleaseInfoNV,VkWin32KeyedMutexAcquireReleaseInfoKHX,VkD3D12FenceSubmitInfoKHX,VkDeviceGroupSubmitInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkWin32KeyedMutexAcquireReleaseInfoNV,VkWin32KeyedMutexAcquireReleaseInfoKHR,VkD3D12FenceSubmitInfoKHR,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> @@ -1577,7 +1584,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type category="struct" name="VkDebugReportCallbackCreateInfoEXT"> <member values="VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member> <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> - <member><type>VkDebugReportFlagsEXT</type> <name>flags</name></member> <!-- Indicates which events call this callback--> + <member optional="true"><type>VkDebugReportFlagsEXT</type> <name>flags</name></member> <!-- Indicates which events call this callback--> <member><type>PFN_vkDebugReportCallbackEXT</type> <name>pfnCallback</name></member> <!-- Function pointer of a callback function--> <member optional="true"><type>void</type>* <name>pUserData</name></member> <!-- User data provided to callback function --> </type> @@ -1771,12 +1778,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 validextensionstructs="VkPhysicalDeviceMultiviewFeaturesKHX"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkPhysicalDevice16BitStorageFeaturesKHR,VkPhysicalDeviceVariablePointerFeaturesKHR,VkPhysicalDeviceMultiviewFeaturesKHX,VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"><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 validextensionstructs="VkPhysicalDevicePushDescriptorPropertiesKHR,VkPhysicalDeviceIDPropertiesKHX,VkPhysicalDeviceMultiviewPropertiesKHX,VkPhysicalDeviceDiscardRectanglePropertiesEXT,VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkPhysicalDevicePushDescriptorPropertiesKHR,VkPhysicalDeviceIDPropertiesKHR,VkPhysicalDeviceMultiviewPropertiesKHX,VkPhysicalDeviceDiscardRectanglePropertiesEXT,VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX,VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT,VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT"><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"> @@ -1786,12 +1793,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 validextensionstructs="VkExternalImageFormatPropertiesKHX"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkExternalImageFormatPropertiesKHR,VkTextureLODGatherFormatPropertiesAMD"><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 validextensionstructs="VkPhysicalDeviceExternalImageFormatInfoKHX">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member validextensionstructs="VkPhysicalDeviceExternalImageFormatInfoKHR">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> @@ -1842,87 +1849,107 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <member><type>VkExtent2D</type> <name>extent</name></member> <!-- Dimensions of a rectangle that has not changed, in pixels of a presentation images --> <member><type>uint32_t</type> <name>layer</name></member> <!-- Layer of a swapchain's image(s), for stereoscopic-3D images --> </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 category="struct" name="VkPhysicalDeviceVariablePointerFeaturesKHR"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBool32</type> <name>variablePointersStorageBuffer</name></member> + <member><type>VkBool32</type> <name>variablePointers</name></member> + </type> + <type category="struct" name="VkExternalMemoryPropertiesKHR" returnedonly="true"> + <member><type>VkExternalMemoryFeatureFlagsKHR</type> <name>externalMemoryFeatures</name></member> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagsKHR</type> <name>exportFromImportedHandleTypes</name></member> + <member><type>VkExternalMemoryHandleTypeFlagsKHR</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> + <type category="struct" name="VkPhysicalDeviceExternalImageFormatInfoKHR"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> <member noautovalidity="true">const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> - <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></member> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHR</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> + <type category="struct" name="VkExternalImageFormatPropertiesKHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR"><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> + <member><type>VkExternalMemoryPropertiesKHR</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> + <type category="struct" name="VkPhysicalDeviceExternalBufferInfoKHR"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR"><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> + <member><type>VkExternalMemoryHandleTypeFlagBitsKHR</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> + <type category="struct" name="VkExternalBufferPropertiesKHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR"><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> + <member><type>VkExternalMemoryPropertiesKHR</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> + <type category="struct" name="VkPhysicalDeviceIDPropertiesKHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR"><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>uint8_t</type> <name>deviceLUID</name>[<enum>VK_LUID_SIZE_KHR</enum>]</member> + <member><type>uint32_t</type> <name>deviceNodeMask</name></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> + <type category="struct" name="VkExternalMemoryImageCreateInfoKHR"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR"><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> + <member><type>VkExternalMemoryHandleTypeFlagsKHR</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> + <type category="struct" name="VkExternalMemoryBufferCreateInfoKHR"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR"><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> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagsKHR</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> + <type category="struct" name="VkExportMemoryAllocateInfoKHR"> + <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR"><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> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagsKHR</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> + <type category="struct" name="VkImportMemoryWin32HandleInfoKHR"> + <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"><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> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + <member optional="true"><type>HANDLE</type> <name>handle</name></member> + <member optional="true"><type>LPCWSTR</type> <name>name</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> + <type category="struct" name="VkExportMemoryWin32HandleInfoKHR"> + <member values="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"><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> + <type category="struct" name="VkMemoryWin32HandlePropertiesKHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_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>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> + <type category="struct" name="VkMemoryGetWin32HandleInfoKHR"> + <member values="VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR"><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>VkDeviceMemory</type> <name>memory</name></member> + <member><type>VkExternalMemoryHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + </type> + <type category="struct" name="VkImportMemoryFdInfoKHR"> + <member values="VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkExternalMemoryHandleTypeFlagBitsKHR</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> + <type category="struct" name="VkMemoryFdPropertiesKHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_MEMORY_FD_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>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> + <type category="struct" name="VkMemoryGetFdInfoKHR"> + <member values="VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkDeviceMemory</type> <name>memory</name></member> + <member><type>VkExternalMemoryHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + </type> + <type category="struct" name="VkWin32KeyedMutexAcquireReleaseInfoKHR"> + <member values="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> <member noautovalidity="true">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> @@ -1932,52 +1959,120 @@ 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="VkPhysicalDeviceExternalSemaphoreInfoKHX"> - <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX"><type>VkStructureType</type> <name>sType</name></member> + <type category="struct" name="VkPhysicalDeviceExternalSemaphoreInfoKHR"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR"><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> + <member><type>VkExternalSemaphoreHandleTypeFlagBitsKHR</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> + <type category="struct" name="VkExternalSemaphorePropertiesKHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR"><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> + <member><type>VkExternalSemaphoreHandleTypeFlagsKHR</type> <name>exportFromImportedHandleTypes</name></member> + <member><type>VkExternalSemaphoreHandleTypeFlagsKHR</type> <name>compatibleHandleTypes</name></member> + <member optional="true"><type>VkExternalSemaphoreFeatureFlagsKHR</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> + <type category="struct" name="VkExportSemaphoreCreateInfoKHR"> + <member values="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR"><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> + <member optional="true"><type>VkExternalSemaphoreHandleTypeFlagsKHR</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> + <type category="struct" name="VkImportSemaphoreWin32HandleInfoKHR"> + <member values="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"><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 externsync="true"><type>VkSemaphore</type> <name>semaphore</name></member> + <member optional="true"><type>VkSemaphoreImportFlagsKHR</type> <name>flags</name></member> + <member optional="true"><type>VkExternalSemaphoreHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + <member optional="true"><type>HANDLE</type> <name>handle</name></member> + <member optional="true"><type>LPCWSTR</type> <name>name</name></member> + </type> + <type category="struct" name="VkExportSemaphoreWin32HandleInfoKHR"> + <member values="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"><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> + <type category="struct" name="VkD3D12FenceSubmitInfoKHR"> + <member values="VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> <member noautovalidity="true">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> + <type category="struct" name="VkSemaphoreGetWin32HandleInfoKHR"> + <member values="VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"><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>VkExternalSemaphoreHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + </type> + <type category="struct" name="VkImportSemaphoreFdInfoKHR"> + <member values="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member externsync="true"><type>VkSemaphore</type> <name>semaphore</name></member> + <member optional="true"><type>VkSemaphoreImportFlagsKHR</type> <name>flags</name></member> + <member><type>VkExternalSemaphoreHandleTypeFlagBitsKHR</type> <name>handleType</name></member> <member><type>int</type> <name>fd</name></member> </type> + <type category="struct" name="VkSemaphoreGetFdInfoKHR"> + <member values="VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"><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>VkExternalSemaphoreHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceExternalFenceInfoKHR"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkExternalFenceHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + </type> + <type category="struct" name="VkExternalFencePropertiesKHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkExternalFenceHandleTypeFlagsKHR</type> <name>exportFromImportedHandleTypes</name></member> + <member><type>VkExternalFenceHandleTypeFlagsKHR</type> <name>compatibleHandleTypes</name></member> + <member optional="true"><type>VkExternalFenceFeatureFlagsKHR</type> <name>externalFenceFeatures</name></member> + </type> + <type category="struct" name="VkExportFenceCreateInfoKHR"> + <member values="VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkExternalFenceHandleTypeFlagsKHR</type> <name>handleTypes</name></member> + </type> + <type category="struct" name="VkImportFenceWin32HandleInfoKHR"> + <member values="VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member externsync="true"><type>VkFence</type> <name>fence</name></member> + <member optional="true"><type>VkFenceImportFlagsKHR</type> <name>flags</name></member> + <member optional="true"><type>VkExternalFenceHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + <member optional="true"><type>HANDLE</type> <name>handle</name></member> + <member optional="true"><type>LPCWSTR</type> <name>name</name></member> + </type> + <type category="struct" name="VkExportFenceWin32HandleInfoKHR"> + <member values="VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"><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="VkFenceGetWin32HandleInfoKHR"> + <member values="VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkFence</type> <name>fence</name></member> + <member><type>VkExternalFenceHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + </type> + <type category="struct" name="VkImportFenceFdInfoKHR"> + <member values="VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member externsync="true"><type>VkFence</type> <name>fence</name></member> + <member optional="true"><type>VkFenceImportFlagsKHR</type> <name>flags</name></member> + <member><type>VkExternalFenceHandleTypeFlagBitsKHR</type> <name>handleType</name></member> + <member><type>int</type> <name>fd</name></member> + </type> + <type category="struct" name="VkFenceGetFdInfoKHR"> + <member values="VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkFence</type> <name>fence</name></member> + <member><type>VkExternalFenceHandleTypeFlagBitsKHR</type> <name>handleType</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 noautovalidity="true"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> @@ -2275,6 +2370,105 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <member noautovalidity="true"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> <member optional="true"><type>VkImageUsageFlags</type> <name>sharedPresentSupportedUsageFlags</name></member> <!-- Supported image usage flags if swapchain created using a shared present mode --> </type> + <type category="struct" name="VkPhysicalDevice16BitStorageFeaturesKHR"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member noautovalidity="true"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBool32</type> <name>storageBuffer16BitAccess</name></member> <!-- 16-bit integer/floating-point variables supported in BufferBlock --> + <member><type>VkBool32</type> <name>uniformAndStorageBuffer16BitAccess</name></member> <!-- 16-bit integer/floating-point variables supported in BufferBlock and Block --> + <member><type>VkBool32</type> <name>storagePushConstant16</name></member> <!-- 16-bit integer/floating-point variables supported in PushConstant --> + <member><type>VkBool32</type> <name>storageInputOutput16</name></member> <!-- 16-bit integer/floating-point variables supported in shader inputs and outputs --> + </type> + <type category="struct" name="VkBufferMemoryRequirementsInfo2KHR"> + <member values="VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR"><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> + </type> + <type category="struct" name="VkImageMemoryRequirementsInfo2KHR"> + <member values="VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkImage</type> <name>image</name></member> + </type> + <type category="struct" name="VkImageSparseMemoryRequirementsInfo2KHR"> + <member values="VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkImage</type> <name>image</name></member> + </type> + <type category="struct" name="VkMemoryRequirements2KHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member validextensionstructs="VkMemoryDedicatedRequirementsKHR"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkMemoryRequirements</type> <name>memoryRequirements</name></member> + </type> + <type category="struct" name="VkSparseImageMemoryRequirements2KHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkSparseImageMemoryRequirements</type> <name>memoryRequirements</name></member> + </type> + <type category="struct" name="VkMemoryDedicatedRequirementsKHR" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBool32</type> <name>prefersDedicatedAllocation</name></member> + <member><type>VkBool32</type> <name>requiresDedicatedAllocation</name></member> + </type> + <type category="struct" name="VkMemoryDedicatedAllocateInfoKHR"> + <member values="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member optional="true"><type>VkImage</type> <name>image</name></member> <!-- Image that this allocation will be bound to --> + <member optional="true"><type>VkBuffer</type> <name>buffer</name></member> <!-- Buffer that this allocation will be bound to --> + </type> + <type category="struct" name="VkTextureLODGatherFormatPropertiesAMD" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBool32</type> <name>supportsTextureGatherLODBiasAMD</name></member> + </type> + <type category="struct" name="VkPipelineCoverageToColorStateCreateInfoNV"> + <member values="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_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>VkPipelineCoverageToColorStateCreateFlagsNV</type> <name>flags</name></member> <!-- Reserved --> + <member><type>VkBool32</type> <name>coverageToColorEnable</name></member> + <member optional="true"><type>uint32_t</type> <name>coverageToColorLocation</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member> + <member><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBool32</type> <name>filterMinmaxSingleComponentFormats</name></member> + <member><type>VkBool32</type> <name>filterMinmaxImageComponentMapping</name></member> + </type> + <type category="struct" name="VkSamplerReductionModeCreateInfoEXT"> + <member values="VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member> + <member>const <type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkSamplerReductionModeEXT</type> <name>reductionMode</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member> + <member noautovalidity="true"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>VkBool32</type> <name>advancedBlendCoherentOperations</name></member> + </type> + <type category="struct" name="VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT" returnedonly="true"> + <member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member> + <member noautovalidity="true"><type>void</type>* <name>pNext</name></member> <!-- Pointer to next structure --> + <member><type>uint32_t</type> <name>advancedBlendMaxColorAttachments</name></member> + <member><type>VkBool32</type> <name>advancedBlendIndependentBlend</name></member> + <member><type>VkBool32</type> <name>advancedBlendNonPremultipliedSrcColor</name></member> + <member><type>VkBool32</type> <name>advancedBlendNonPremultipliedDstColor</name></member> + <member><type>VkBool32</type> <name>advancedBlendCorrelatedOverlap</name></member> + <member><type>VkBool32</type> <name>advancedBlendAllOperations</name></member> + </type> + <type category="struct" name="VkPipelineColorBlendAdvancedStateCreateInfoEXT"> + <member values="VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_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><type>VkBool32</type> <name>srcPremultiplied</name></member> + <member><type>VkBool32</type> <name>dstPremultiplied</name></member> + <member><type>VkBlendOverlapEXT</type> <name>blendOverlap</name></member> + </type> + <type category="struct" name="VkPipelineCoverageModulationStateCreateInfoNV"> + <member values="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_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>VkPipelineCoverageModulationStateCreateFlagsNV</type> <name>flags</name></member> <!-- Reserved --> + <member><type>VkCoverageModulationModeNV</type> <name>coverageModulationMode</name></member> + <member><type>VkBool32</type> <name>coverageModulationTableEnable</name></member> + <member><type>uint32_t</type> <name>coverageModulationTableCount</name></member> + <member noautovalidity="true" optional="true" len="coverageModulationTableCount">const <type>float</type>* <name>pCoverageModulationTable</name></member> + </type> </types> <!-- SECTION: Vulkan enumerant (token) definitions. --> @@ -2283,7 +2477,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="8" name="VK_LUID_SIZE_KHR"/> <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"/> @@ -2296,7 +2490,7 @@ 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-1)" name="VK_QUEUE_FAMILY_EXTERNAL_KHR"/> <enum value="(~0U)" name="VK_SUBPASS_EXTERNAL"/> <enum value="32" name="VK_MAX_DEVICE_GROUP_SIZE_KHX"/> </enums> @@ -3109,16 +3303,12 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value="25" name="VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT"/> <enum value="26" name="VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT"/> <enum value="27" name="VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT"/> - <enum value="28" name="VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT"/> + <enum value="28" name="VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT"/> <enum value="29" name="VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT"/> <enum value="30" name="VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT"/> <enum value="31" name="VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT"/> <enum value="32" name="VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT"/> </enums> - <enums name="VkDebugReportErrorEXT" type="enum"> - <enum value="0" name="VK_DEBUG_REPORT_ERROR_NONE_EXT"/> <!-- Used for INFO & other non-error messages --> - <enum value="1" name="VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT"/> <!-- Callbacks were not destroyed prior to calling DestroyInstance --> - </enums> <enums name="VkRasterizationOrderAMD" type="enum"> <enum value="0" name="VK_RASTERIZATION_ORDER_STRICT_AMD"/> <!-- Rasterization order strictly follows API order --> <enum value="1" name="VK_RASTERIZATION_ORDER_RELAXED_AMD"/> <!-- Rasterization order may not follow API order --> @@ -3136,6 +3326,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </enums> <enums name="VkValidationCheckEXT" type="enum"> <enum value="0" name="VK_VALIDATION_CHECK_ALL_EXT"/> + <enum value="1" name="VK_VALIDATION_CHECK_SHADERS_EXT"/> <!-- Placeholder for validation enums to be defined for VK_EXT_Validation_flags extension --> </enums> <enums name="VkIndirectCommandsLayoutUsageFlagBitsNVX" type="bitmask"> @@ -3149,48 +3340,64 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum bitpos="1" name="VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX"/> </enums> <enums name="VkIndirectCommandsTokenTypeNVX" type="enum"> - <enum value="0" name="VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX"/> <!-- array of 32bit tableEntry in the object table --> - <enum value="1" name="VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX"/> <!-- array of (32 bit tableEntry + variable count 32bit offsets) --> - <enum value="2" name="VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX"/> <!-- array of (32 bit tableEntry + optional 32bit offset) --> - <enum value="3" name="VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX"/> <!-- array of (32 bit tableEntry + optional 32bit offset) --> - <enum value="4" name="VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX"/> <!-- array of (32 bit tableEntry + variable count 32bit values ) --> - <enum value="5" name="VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX"/> <!-- array of VkDrawIndexedIndirectCommand --> - <enum value="6" name="VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX"/> <!-- array of VkDrawIndirectCommand --> - <enum value="7" name="VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX"/> <!-- array of VkDispatchIndirectCommand --> + <enum value="0" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX"/> <!-- array of 32bit tableEntry in the object table --> + <enum value="1" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX"/> <!-- array of (32 bit tableEntry + variable count 32bit offsets) --> + <enum value="2" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX"/> <!-- array of (32 bit tableEntry + optional 32bit offset) --> + <enum value="3" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX"/> <!-- array of (32 bit tableEntry + optional 32bit offset) --> + <enum value="4" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX"/> <!-- array of (32 bit tableEntry + variable count 32bit values ) --> + <enum value="5" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX"/> <!-- array of VkDrawIndexedIndirectCommand --> + <enum value="6" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX"/> <!-- array of VkDrawIndirectCommand --> + <enum value="7" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX"/> <!-- array of VkDispatchIndirectCommand --> </enums> <enums name="VkObjectEntryTypeNVX" type="enum"> - <enum value="0" name="VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX"/> - <enum value="1" name="VK_OBJECT_ENTRY_PIPELINE_NVX"/> - <enum value="2" name="VK_OBJECT_ENTRY_INDEX_BUFFER_NVX"/> - <enum value="3" name="VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX"/> - <enum value="4" name="VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX"/> + <enum value="0" name="VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX"/> + <enum value="1" name="VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX"/> + <enum value="2" name="VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX"/> + <enum value="3" name="VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX"/> + <enum value="4" name="VK_OBJECT_ENTRY_TYPE_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 name="VkExternalMemoryHandleTypeFlagBitsKHR" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR"/> + <enum bitpos="1" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR"/> + <enum bitpos="2" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR"/> + <enum bitpos="3" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR"/> + <enum bitpos="4" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR"/> + <enum bitpos="5" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR"/> + <enum bitpos="6" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR"/> + </enums> + <enums name="VkExternalMemoryFeatureFlagBitsKHR" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR"/> + <enum bitpos="1" name="VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR"/> + <enum bitpos="2" name="VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR"/> + </enums> + <enums name="VkExternalSemaphoreHandleTypeFlagBitsKHR" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR"/> + <enum bitpos="1" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR"/> + <enum bitpos="2" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR"/> + <enum bitpos="3" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR"/> + <enum bitpos="4" name="VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR"/> </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 name="VkExternalSemaphoreFeatureFlagBitsKHR" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR"/> + <enum bitpos="1" name="VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR"/> </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 name="VkSemaphoreImportFlagBitsKHR" type="bitmask"> + <enum bitpos="0" name="VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR"/> </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 name="VkExternalFenceHandleTypeFlagBitsKHR" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR"/> + <enum bitpos="1" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR"/> + <enum bitpos="2" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR"/> + <enum bitpos="3" name="VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR"/> + </enums> + <enums name="VkExternalFenceFeatureFlagBitsKHR" type="bitmask"> + <enum bitpos="0" name="VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR"/> + <enum bitpos="1" name="VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR"/> + </enums> + <enums name="VkFenceImportFlagBitsKHR" type="bitmask"> + <enum bitpos="0" name="VK_FENCE_IMPORT_TEMPORARY_BIT_KHR"/> </enums> <enums name="VkSurfaceCounterFlagBitsEXT" type="bitmask"> <enum bitpos="0" name="VK_SURFACE_COUNTER_VBLANK_EXT"/> @@ -3239,7 +3446,22 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </enums> <enums name="VkSubpassDescriptionFlagBits" type="bitmask"> </enums> - + <enums name="VkSamplerReductionModeEXT" type="enum"> + <enum value="0" name="VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT"/> + <enum value="1" name="VK_SAMPLER_REDUCTION_MODE_MIN_EXT"/> + <enum value="2" name="VK_SAMPLER_REDUCTION_MODE_MAX_EXT"/> + </enums> + <enums name="VkBlendOverlapEXT" type="enum"> + <enum value="0" name="VK_BLEND_OVERLAP_UNCORRELATED_EXT"/> + <enum value="1" name="VK_BLEND_OVERLAP_DISJOINT_EXT"/> + <enum value="2" name="VK_BLEND_OVERLAP_CONJOINT_EXT"/> + </enums> + <enums name="VkCoverageModulationModeNV" type="enum"> + <enum value="0" name="VK_COVERAGE_MODULATION_MODE_NONE_NV"/> + <enum value="1" name="VK_COVERAGE_MODULATION_MODE_RGB_NV"/> + <enum value="2" name="VK_COVERAGE_MODULATION_MODE_ALPHA_NV"/> + <enum value="3" name="VK_COVERAGE_MODULATION_MODE_RGBA_NV"/> + </enums> <!-- SECTION: Vulkan command definitions --> <commands> @@ -3368,7 +3590,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,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX"> + <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_KHR"> <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> @@ -4592,75 +4814,99 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <param optional="true"><type>VkCommandPoolTrimFlagsKHR</type> <name>flags</name></param> </command> <command> - <proto><type>void</type> <name>vkGetPhysicalDeviceExternalBufferPropertiesKHX</name></proto> + <proto><type>void</type> <name>vkGetPhysicalDeviceExternalBufferPropertiesKHR</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> + <param>const <type>VkPhysicalDeviceExternalBufferInfoKHR</type>* <name>pExternalBufferInfo</name></param> + <param><type>VkExternalBufferPropertiesKHR</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> + <proto><type>VkResult</type> <name>vkGetMemoryWin32HandleKHR</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>const <type>VkMemoryGetWin32HandleInfoKHR</type>* <name>pGetWin32HandleInfo</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> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR"> + <proto><type>VkResult</type> <name>vkGetMemoryWin32HandlePropertiesKHR</name></proto> <param><type>VkDevice</type> <name>device</name></param> - <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param> + <param><type>VkExternalMemoryHandleTypeFlagBitsKHR</type> <name>handleType</name></param> <param><type>HANDLE</type> <name>handle</name></param> - <param><type>VkMemoryWin32HandlePropertiesKHX</type>* <name>pMemoryWin32HandleProperties</name></param> + <param><type>VkMemoryWin32HandlePropertiesKHR</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> + <proto><type>VkResult</type> <name>vkGetMemoryFdKHR</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>const <type>VkMemoryGetFdInfoKHR</type>* <name>pGetFdInfo</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> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR"> + <proto><type>VkResult</type> <name>vkGetMemoryFdPropertiesKHR</name></proto> <param><type>VkDevice</type> <name>device</name></param> - <param><type>VkExternalMemoryHandleTypeFlagBitsKHX</type> <name>handleType</name></param> + <param><type>VkExternalMemoryHandleTypeFlagBitsKHR</type> <name>handleType</name></param> <param><type>int</type> <name>fd</name></param> - <param><type>VkMemoryFdPropertiesKHX</type>* <name>pMemoryFdProperties</name></param> + <param><type>VkMemoryFdPropertiesKHR</type>* <name>pMemoryFdProperties</name></param> + </command> + <command> + <proto><type>void</type> <name>vkGetPhysicalDeviceExternalSemaphorePropertiesKHR</name></proto> + <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> + <param>const <type>VkPhysicalDeviceExternalSemaphoreInfoKHR</type>* <name>pExternalSemaphoreInfo</name></param> + <param><type>VkExternalSemaphorePropertiesKHR</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>vkGetSemaphoreWin32HandleKHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkSemaphoreGetWin32HandleInfoKHR</type>* <name>pGetWin32HandleInfo</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_KHR"> + <proto><type>VkResult</type> <name>vkImportSemaphoreWin32HandleKHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkImportSemaphoreWin32HandleInfoKHR</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>vkGetSemaphoreFdKHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkSemaphoreGetFdInfoKHR</type>* <name>pGetFdInfo</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_KHR"> + <proto><type>VkResult</type> <name>vkImportSemaphoreFdKHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkImportSemaphoreFdInfoKHR</type>* <name>pImportSemaphoreFdInfo</name></param> </command> <command> - <proto><type>void</type> <name>vkGetPhysicalDeviceExternalSemaphorePropertiesKHX</name></proto> + <proto><type>void</type> <name>vkGetPhysicalDeviceExternalFencePropertiesKHR</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> + <param>const <type>VkPhysicalDeviceExternalFenceInfoKHR</type>* <name>pExternalFenceInfo</name></param> + <param><type>VkExternalFencePropertiesKHR</type>* <name>pExternalFenceProperties</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> + <proto><type>VkResult</type> <name>vkGetFenceWin32HandleKHR</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>const <type>VkFenceGetWin32HandleInfoKHR</type>* <name>pGetWin32HandleInfo</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> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR"> + <proto><type>VkResult</type> <name>vkImportFenceWin32HandleKHR</name></proto> <param><type>VkDevice</type> <name>device</name></param> - <param>const <type>VkImportSemaphoreWin32HandleInfoKHX</type>* <name>pImportSemaphoreWin32HandleInfo</name></param> + <param>const <type>VkImportFenceWin32HandleInfoKHR</type>* <name>pImportFenceWin32HandleInfo</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> + <proto><type>VkResult</type> <name>vkGetFenceFdKHR</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>const <type>VkFenceGetFdInfoKHR</type>* <name>pGetFdInfo</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> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR"> + <proto><type>VkResult</type> <name>vkImportFenceFdKHR</name></proto> <param><type>VkDevice</type> <name>device</name></param> - <param>const <type>VkImportSemaphoreFdInfoKHX</type>* <name>pImportSemaphoreFdInfo</name></param> + <param>const <type>VkImportFenceFdInfoKHR</type>* <name>pImportFenceFdInfo</name></param> </command> <command successcodes="VK_SUCCESS"> <proto><type>VkResult</type> <name>vkReleaseDisplayEXT</name></proto> <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> <param><type>VkDisplayKHR</type> <name>display</name></param> </command> - <command successcodes="VK_SUCCESS"> + <command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_INITIALIZATION_FAILED"> <proto><type>VkResult</type> <name>vkAcquireXlibDisplayEXT</name></proto> <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> <param><type>Display</type>* <name>dpy</name></param> @@ -4853,7 +5099,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <param><type>uint32_t</type> <name>discardRectangleCount</name></param> <param len="discardRectangleCount">const <type>VkRect2D</type>* <name>pDiscardRectangles</name></param> </command> - <command errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_SURFACE_LOST_KHR"> + <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>vkGetPhysicalDeviceSurfaceCapabilities2KHR</name></proto> <param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param> <param>const <type>VkPhysicalDeviceSurfaceInfo2KHR</type>* <name>pSurfaceInfo</name></param> @@ -4866,6 +5112,25 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <param optional="false,true"><type>uint32_t</type>* <name>pSurfaceFormatCount</name></param> <param optional="true" len="pSurfaceFormatCount"><type>VkSurfaceFormat2KHR</type>* <name>pSurfaceFormats</name></param> </command> + <command> + <proto><type>void</type> <name>vkGetBufferMemoryRequirements2KHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkBufferMemoryRequirementsInfo2KHR</type>* <name>pInfo</name></param> + <param><type>VkMemoryRequirements2KHR</type>* <name>pMemoryRequirements</name></param> + </command> + <command> + <proto><type>void</type> <name>vkGetImageMemoryRequirements2KHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkImageMemoryRequirementsInfo2KHR</type>* <name>pInfo</name></param> + <param><type>VkMemoryRequirements2KHR</type>* <name>pMemoryRequirements</name></param> + </command> + <command> + <proto><type>void</type> <name>vkGetImageSparseMemoryRequirements2KHR</name></proto> + <param><type>VkDevice</type> <name>device</name></param> + <param>const <type>VkImageSparseMemoryRequirementsInfo2KHR</type>* <name>pInfo</name></param> + <param optional="false,true"><type>uint32_t</type>* <name>pSparseMemoryRequirementCount</name></param> + <param optional="true" len="pSparseMemoryRequirementCount"><type>VkSparseImageMemoryRequirements2KHR</type>* <name>pSparseMemoryRequirements</name></param> + </command> </commands> <!-- SECTION: Vulkan API interface definitions --> @@ -5225,7 +5490,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </extension> <extension name="VK_KHR_win32_surface" number="10" type="instance" requires="VK_KHR_surface" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> <require> - <enum value="5" name="VK_KHR_WIN32_SURFACE_SPEC_VERSION"/> + <enum value="6" name="VK_KHR_WIN32_SURFACE_SPEC_VERSION"/> <enum value=""VK_KHR_win32_surface"" name="VK_KHR_WIN32_SURFACE_EXTENSION_NAME"/> <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR"/> <type name="VkWin32SurfaceCreateFlagsKHR"/> @@ -5243,27 +5508,28 @@ maintained in the master branch of the Khronos Vulkan GitHub project. </extension> <extension name="VK_EXT_debug_report" number="12" type="instance" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney" supported="vulkan"> <require> - <enum value="6" name="VK_EXT_DEBUG_REPORT_SPEC_VERSION"/> + <enum value="8" 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"/> <enum value="VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT" name="VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT"/> <enum offset="0" extends="VkObjectType" name="VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT" comment="VkDebugReportCallbackEXT"/> + <enum value="VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT" name="VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT"/> <type name="VkDebugReportObjectTypeEXT"/> - <type name="VkDebugReportErrorEXT"/> + <type name="VkDebugReportCallbackCreateInfoEXT"/> <command name="vkCreateDebugReportCallbackEXT"/> <command name="vkDestroyDebugReportCallbackEXT"/> <command name="vkDebugReportMessageEXT"/> </require> </extension> - <extension name="VK_NV_glsl_shader" number="13" type="device" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="vulkan"> + <extension name="VK_NV_glsl_shader" number="13" type="device" author="NV" contact="Piers Daniell @pdaniell" supported="vulkan"> <require> <enum value="1" name="VK_NV_GLSL_SHADER_SPEC_VERSION"/> <enum value=""VK_NV_glsl_shader"" name="VK_NV_GLSL_SHADER_EXTENSION_NAME"/> <enum offset="0" dir="-" extends="VkResult" name="VK_ERROR_INVALID_SHADER_NV"/> </require> </extension> - <extension name="VK_NV_extension_1" number="14" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="disabled"> + <extension name="VK_NV_extension_1" number="14" author="NV" contact="Piers Daniell @pdaniell" supported="disabled"> <require> <enum value="0" name="VK_NV_EXTENSION_1_SPEC_VERSION"/> <enum value=""VK_NV_extension_1"" name="VK_NV_EXTENSION_1_EXTENSION_NAME"/> @@ -5360,7 +5626,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_AMD_gcn_shader"" name="VK_AMD_GCN_SHADER_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_dedicated_allocation" number="27" type="device" author="NVIDIA" contact="Jeff Bolz @jbolz" supported="vulkan"> + <extension name="VK_NV_dedicated_allocation" number="27" type="device" author="NV" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> <enum value="1" name="VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION"/> <enum value=""VK_NV_dedicated_allocation"" name="VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME"/> @@ -5372,25 +5638,25 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkDedicatedAllocationMemoryAllocateInfoNV"/> </require> </extension> - <extension name="VK_EXT_extension_28" number="28" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="disabled"> + <extension name="VK_EXT_extension_28" number="28" author="NV" contact="Piers Daniell @pdaniell" supported="disabled"> <require> <enum value="0" name="VK_EXT_EXTENSION_28_SPEC_VERSION"/> <enum value=""VK_NV_extension_28"" name="VK_EXT_EXTENSION_28_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NVX_extension_29" number="29" author="NVIDIA" contact="Jeff Juliano @jjuliano" supported="disabled"> + <extension name="VK_NVX_extension_29" number="29" author="NVX" contact="Jeff Juliano @jjuliano" supported="disabled"> <require> <enum value="0" name="VK_NVX_EXTENSION_29_SPEC_VERSION"/> <enum value=""VK_NVX_extension_29"" name="VK_NVX_EXTENSION_29_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NVX_extension_30" number="30" author="NVIDIA" contact="Jeff Juliano @jjuliano" supported="disabled"> + <extension name="VK_NVX_extension_30" number="30" author="NVX" contact="Jeff Juliano @jjuliano" supported="disabled"> <require> <enum value="0" name="VK_NVX_EXTENSION_30_SPEC_VERSION"/> <enum value=""VK_NVX_extension_30"" name="VK_NVX_EXTENSION_30_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NVX_extension_31" number="31" author="NVIDIA" contact="Jeff Juliano @jjuliano" supported="disabled"> + <extension name="VK_NVX_extension_31" number="31" author="NVX" contact="Jeff Juliano @jjuliano" supported="disabled"> <require> <enum value="0" name="VK_NVX_EXTENSION_31_SPEC_VERSION"/> <enum value=""VK_NVX_extension_31"" name="VK_NVX_EXTENSION_31_EXTENSION_NAME"/> @@ -5458,10 +5724,12 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_AMD_extension_41"" name="VK_AMD_EXTENSION_41_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_AMD_extension_42" number="42" author="AMD" contact="Daniel Rakos @aqnuep" supported="disabled"> + <extension name="VK_AMD_texture_gather_bias_lod" number="42" author="AMD" contact="Rex Xu @amdrexu" supported="vulkan" type="device" requires="VK_KHR_get_physical_device_properties2"> <require> - <enum value="0" name="VK_AMD_EXTENSION_42_SPEC_VERSION"/> - <enum value=""VK_AMD_extension_42"" name="VK_AMD_EXTENSION_42_EXTENSION_NAME"/> + <enum value="1" name="VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION"/> + <enum value=""VK_AMD_texture_gather_bias_lod"" name="VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"/> + <type name="VkTextureLODGatherFormatPropertiesAMD"/> </require> </extension> <extension name="VK_AMD_extension_43" number="43" author="AMD" contact="Daniel Rakos @aqnuep" supported="disabled"> @@ -5494,7 +5762,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_AMD_extension_47"" name="VK_AMD_EXTENSION_47_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NVX_extension_48" number="48" author="NVIDIA" contact="James Jones @cubanismo" supported="disabled"> + <extension name="VK_NVX_extension_48" number="48" author="NVX" contact="James Jones @cubanismo" supported="disabled"> <require> <enum value="0" name="VK_NVX_EXTENSION_48_SPEC_VERSION"/> <enum value=""VK_NVX_extension_48"" name="VK_NVX_EXTENSION_48_EXTENSION_NAME"/> @@ -5512,25 +5780,25 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_GOOGLE_extension_50"" name="VK_GOOGLE_EXTENSION_50_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NVX_extension_51" number="51" author="NVIDIA" contact="James Jones @cubanismo" supported="disabled"> + <extension name="VK_NVX_extension_51" number="51" author="NVX" contact="James Jones @cubanismo" supported="disabled"> <require> <enum value="0" name="VK_NVX_EXTENSION_51_SPEC_VERSION"/> <enum value=""VK_NVX_extension_51"" name="VK_NVX_EXTENSION_51_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NVX_extension_52" number="52" author="NVIDIA" contact="James Jones @cubanismo" supported="disabled"> + <extension name="VK_NVX_extension_52" number="52" author="NVX" contact="James Jones @cubanismo" supported="disabled"> <require> <enum value="0" name="VK_NVX_EXTENSION_52_SPEC_VERSION"/> <enum value=""VK_NVX_extension_52"" name="VK_NVX_EXTENSION_52_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_53" number="53" author="NVIDIA" contact="Jeff Bolz @jbolz" supported="disabled"> + <extension name="VK_NV_extension_53" number="53" author="NV" contact="Jeff Bolz @jbolz" supported="disabled"> <require> <enum value="0" name="VK_NV_EXTENSION_53_SPEC_VERSION"/> <enum value=""VK_NV_extension_53"" name="VK_NV_EXTENSION_53_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_KHX_multiview" number="54" type="device" author="NVIDIA" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jbolz" supported="vulkan"> + <extension name="VK_KHX_multiview" number="54" type="device" author="NV" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> <enum value="1" name="VK_KHX_MULTIVIEW_SPEC_VERSION"/> <enum value=""VK_KHX_multiview"" name="VK_KHX_MULTIVIEW_EXTENSION_NAME"/> @@ -5557,7 +5825,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum offset="7" extends="VkFormat" name="VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"/> </require> </extension> - <extension name="VK_NV_external_memory_capabilities" number="56" type="instance" author="NVIDIA" contact="James jones @cubanismo" supported="vulkan"> + <extension name="VK_NV_external_memory_capabilities" number="56" type="instance" author="NV" contact="James Jones @cubanismo" supported="vulkan"> <require> <enum value="1" name="VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION"/> <enum value=""VK_NV_external_memory_capabilities"" name="VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME"/> @@ -5569,7 +5837,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkGetPhysicalDeviceExternalImageFormatPropertiesNV"/> </require> </extension> - <extension name="VK_NV_external_memory" number="57" type="device" requires="VK_NV_external_memory_capabilities" author="NVIDIA" contact="James jones @cubanismo" supported="vulkan"> + <extension name="VK_NV_external_memory" number="57" type="device" requires="VK_NV_external_memory_capabilities" author="NV" contact="James Jones @cubanismo" supported="vulkan"> <require> <enum value="1" name="VK_NV_EXTERNAL_MEMORY_SPEC_VERSION"/> <enum value=""VK_NV_external_memory"" name="VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME"/> @@ -5579,7 +5847,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkExportMemoryAllocateInfoNV"/> </require> </extension> - <extension name="VK_NV_external_memory_win32" number="58" type="device" requires="VK_NV_external_memory_capabilities,VK_NV_external_memory" author="NVIDIA" contact="James jones @cubanismo" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> + <extension name="VK_NV_external_memory_win32" number="58" type="device" requires="VK_NV_external_memory_capabilities,VK_NV_external_memory" author="NV" contact="James Jones @cubanismo" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> <require> <enum value="1" name="VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION"/> <enum value=""VK_NV_external_memory_win32"" name="VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME"/> @@ -5590,7 +5858,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkGetMemoryWin32HandleNV"/> </require> </extension> - <extension name="VK_NV_win32_keyed_mutex" number="59" type="device" requires="VK_NV_external_memory_capabilities,VK_NV_external_memory_win32" author="NVIDIA" contact="Carsten Rohde" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> + <extension name="VK_NV_win32_keyed_mutex" number="59" type="device" requires="VK_NV_external_memory_capabilities,VK_NV_external_memory_win32" author="NV" contact="Carsten Rohde" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> <require> <enum value="1" name="VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION"/> <enum value=""VK_NV_win32_keyed_mutex"" name="VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME"/> @@ -5629,7 +5897,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkGetPhysicalDeviceSparseImageFormatProperties2KHR"/> </require> </extension> - <extension name="VK_KHX_device_group" number="61" type="device" author="KHX" requires="VK_KHR_swapchain" contact="Jeff Bolz @jbolz" supported="vulkan"> + <extension name="VK_KHX_device_group" number="61" type="device" author="KHX" requires="VK_KHR_swapchain,VK_KHX_device_group_creation" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> <enum value="1" name="VK_KHX_DEVICE_GROUP_SPEC_VERSION"/> <enum value=""VK_KHX_device_group"" name="VK_KHX_DEVICE_GROUP_EXTENSION_NAME"/> @@ -5705,13 +5973,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" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> + <extension name="VK_EXT_shader_subgroup_ballot" number="65" type="device" author="NV" 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" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> + <extension name="VK_EXT_shader_subgroup_vote" number="66" type="device" author="NV" 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"/> @@ -5759,124 +6027,134 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <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_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="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 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"/> - <command name="vkGetPhysicalDeviceExternalBufferPropertiesKHX"/> - </require> - </extension> - <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="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_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_KHX" supported="vulkan"> - <require> - <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_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="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_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="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_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="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"/> - <command name="vkGetPhysicalDeviceExternalSemaphorePropertiesKHX"/> - </require> - </extension> - <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="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_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="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_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="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"/> + <extension name="VK_KHR_external_memory_capabilities" number="72" type="instance" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="James Jones @cubanismo" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION"/> + <enum value=""VK_KHR_external_memory_capabilities"" name="VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR"/> + <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR"/> + <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR"/> + <enum name="VK_LUID_SIZE_KHR"/> + <type name="VkExternalMemoryHandleTypeFlagsKHR"/> + <type name="VkExternalMemoryHandleTypeFlagBitsKHR"/> + <type name="VkExternalMemoryFeatureFlagsKHR"/> + <type name="VkExternalMemoryFeatureFlagBitsKHR"/> + <type name="VkExternalMemoryPropertiesKHR"/> + <type name="VkPhysicalDeviceExternalImageFormatInfoKHR"/> + <type name="VkExternalImageFormatPropertiesKHR"/> + <type name="VkPhysicalDeviceExternalBufferInfoKHR"/> + <type name="VkExternalBufferPropertiesKHR"/> + <type name="VkPhysicalDeviceIDPropertiesKHR"/> + <command name="vkGetPhysicalDeviceExternalBufferPropertiesKHR"/> + </require> + </extension> + <extension name="VK_KHR_external_memory" number="73" type="device" requires="VK_KHR_external_memory_capabilities" author="KHR" contact="James Jones @cubanismo" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION"/> + <enum value=""VK_KHR_external_memory"" name="VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR"/> + <enum offset="3" dir="-" extends="VkResult" name="VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR"/> + <enum name="VK_QUEUE_FAMILY_EXTERNAL_KHR"/> + <type name="VkExternalMemoryImageCreateInfoKHR"/> + <type name="VkExternalMemoryBufferCreateInfoKHR"/> + <type name="VkExportMemoryAllocateInfoKHR"/> + </require> + </extension> + <extension name="VK_KHR_external_memory_win32" number="74" type="device" requires="VK_KHR_external_memory_capabilities,VK_KHR_external_memory" author="KHR" contact="James Jones @cubanismo" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION"/> + <enum value=""VK_KHR_external_memory_win32"" name="VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR"/> + <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR"/> + <type name="VkImportMemoryWin32HandleInfoKHR"/> + <type name="VkExportMemoryWin32HandleInfoKHR"/> + <type name="VkMemoryWin32HandlePropertiesKHR"/> + <type name="VkMemoryGetWin32HandleInfoKHR"/> + <command name="vkGetMemoryWin32HandleKHR"/> + <command name="vkGetMemoryWin32HandlePropertiesKHR"/> + </require> + </extension> + <extension name="VK_KHR_external_memory_fd" number="75" type="device" requires="VK_KHR_external_memory_capabilities,VK_KHR_external_memory" author="KHX" contact="James Jones @cubanismo" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION"/> + <enum value=""VK_KHR_external_memory_fd"" name="VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR"/> + <type name="VkImportMemoryFdInfoKHR"/> + <type name="VkMemoryFdPropertiesKHR"/> + <type name="VkMemoryGetFdInfoKHR"/> + <command name="vkGetMemoryFdKHR"/> + <command name="vkGetMemoryFdPropertiesKHR"/> + </require> + </extension> + <extension name="VK_KHR_win32_keyed_mutex" number="76" type="device" requires="VK_KHR_external_memory_capabilities,VK_KHR_external_memory,VK_KHR_external_memory_win32" author="KHR" contact="Carsten Rohde" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION"/> + <enum value=""VK_KHR_win32_keyed_mutex"" name="VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"/> + <type name="VkWin32KeyedMutexAcquireReleaseInfoKHR"/> + </require> + </extension> + <extension name="VK_KHR_external_semaphore_capabilities" number="77" type="instance" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="James Jones @cubanismo" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION"/> + <enum value=""VK_KHR_external_semaphore_capabilities"" name="VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR"/> + <enum name="VK_LUID_SIZE_KHR"/> + <type name="VkExternalSemaphoreHandleTypeFlagsKHR"/> + <type name="VkExternalSemaphoreHandleTypeFlagBitsKHR"/> + <type name="VkExternalSemaphoreFeatureFlagsKHR"/> + <type name="VkExternalSemaphoreFeatureFlagBitsKHR"/> + <type name="VkPhysicalDeviceExternalSemaphoreInfoKHR"/> + <type name="VkExternalSemaphorePropertiesKHR"/> + <type name="VkPhysicalDeviceIDPropertiesKHR"/> + <command name="vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"/> + </require> + </extension> + <extension name="VK_KHR_external_semaphore" number="78" type="device" requires="VK_KHR_external_semaphore_capabilities" author="KHR" contact="James Jones @cubanismo" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION"/> + <enum value=""VK_KHR_external_semaphore"" name="VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR"/> + <type name="VkSemaphoreImportFlagsKHR"/> + <type name="VkSemaphoreImportFlagBitsKHR"/> + <type name="VkExportSemaphoreCreateInfoKHR"/> + </require> + </extension> + <extension name="VK_KHR_external_semaphore_win32" number="79" type="device" requires="VK_KHR_external_semaphore_capabilities,VK_KHR_external_semaphore" author="KHR" contact="James Jones @cubanismo" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION"/> + <enum value=""VK_KHR_external_semaphore_win32"" name="VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR"/> + <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"/> + <type name="VkImportSemaphoreWin32HandleInfoKHR"/> + <type name="VkExportSemaphoreWin32HandleInfoKHR"/> + <type name="VkD3D12FenceSubmitInfoKHR"/> + <type name="VkSemaphoreGetWin32HandleInfoKHR"/> + <command name="vkImportSemaphoreWin32HandleKHR"/> + <command name="vkGetSemaphoreWin32HandleKHR"/> + </require> + </extension> + <extension name="VK_KHR_external_semaphore_fd" number="80" type="device" requires="VK_KHR_external_semaphore_capabilities,VK_KHR_external_semaphore" author="KHR" contact="James Jones @cubanismo" supported="vulkan"> + <require> + <enum value="1" name="VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION"/> + <enum value=""VK_KHR_external_semaphore_fd"" name="VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR"/> + <type name="VkImportSemaphoreFdInfoKHR"/> + <type name="VkSemaphoreGetFdInfoKHR"/> + <command name="vkImportSemaphoreFdKHR"/> + <command name="vkGetSemaphoreFdKHR"/> </require> </extension> <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"> @@ -5901,10 +6179,12 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_KHR_extension_83"" name="VK_KHR_EXTENSION_83_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_KHR_extension_84" number="84" author="KHR" contact="Jan-Harald Fredriksen @janharald" supported="disabled"> + <extension name="VK_KHR_16bit_storage" number="84" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_storage_buffer_storage_class" author="KHR" contact="Jan-Harald Fredriksen @janharald" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_84_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_84"" name="VK_KHR_EXTENSION_84_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_16BIT_STORAGE_SPEC_VERSION"/> + <enum value=""VK_KHR_16bit_storage"" name="VK_KHR_16BIT_STORAGE_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR"/> + <type name="VkPhysicalDevice16BitStorageFeaturesKHR"/> </require> </extension> <extension name="VK_KHR_incremental_present" number="85" type="device" author="KHR" requires="VK_KHR_swapchain" contact="Ian Elliott [email protected]" supported="vulkan"> @@ -5935,7 +6215,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkDescriptorUpdateTemplateCreateInfoKHR"/> </require> </extension> - <extension name="VK_NVX_device_generated_commands" number="87" type="device" author="NVIDIA" contact="Christoph Kubisch @pixeljetstream" supported="vulkan"> + <extension name="VK_NVX_device_generated_commands" number="87" type="device" author="NVX" contact="Christoph Kubisch @pixeljetstream" supported="vulkan"> <require> <enum value="1" name="VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION"/> <enum value=""VK_NVX_device_generated_commands"" name="VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME"/> @@ -5994,14 +6274,14 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <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"> + <extension name="VK_EXT_direct_mode_display" number="89" type="instance" requires="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan"> <require> <enum value="1" name="VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION"/> <enum value=""VK_EXT_direct_mode_display"" name="VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME"/> <command name="vkReleaseDisplayEXT"/> </require> </extension> - <extension name="VK_EXT_acquire_xlib_display" number="90" type="instance" requires="VK_EXT_direct_mode_display,VK_KHR_display" author="NVIDIA" contact="James Jones @cubanismo" protect="VK_USE_PLATFORM_XLIB_XRANDR_EXT" supported="vulkan"> + <extension name="VK_EXT_acquire_xlib_display" number="90" type="instance" requires="VK_EXT_direct_mode_display,VK_KHR_display" author="NV" contact="James Jones @cubanismo" protect="VK_USE_PLATFORM_XLIB_XRANDR_EXT" supported="vulkan"> <require> <enum value="1" name="VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION"/> <enum value=""VK_EXT_acquire_xlib_display"" name="VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME"/> @@ -6009,7 +6289,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkGetRandROutputDisplayEXT"/> </require> </extension> - <extension name="VK_EXT_display_surface_counter" number="91" type="instance" requires="VK_KHR_display" author="NVIDIA" contact="James Jones @cubanismo" supported="vulkan"> + <extension name="VK_EXT_display_surface_counter" number="91" type="instance" requires="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan"> <require> <enum value="1" name="VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION"/> <enum value=""VK_EXT_display_surface_counter"" name="VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME"/> @@ -6020,7 +6300,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkGetPhysicalDeviceSurfaceCapabilities2EXT"/> </require> </extension> - <extension name="VK_EXT_display_control" number="92" type="device" requires="VK_KHR_display,VK_EXT_display_surface_counter,VK_KHR_swapchain" author="NVIDIA" contact="James Jones @cubanismo" supported="vulkan"> + <extension name="VK_EXT_display_control" number="92" type="device" requires="VK_KHR_display,VK_EXT_display_surface_counter,VK_KHR_swapchain" author="NV" contact="James Jones @cubanismo" supported="vulkan"> <require> <enum value="1" name="VK_EXT_DISPLAY_CONTROL_SPEC_VERSION"/> <enum value=""VK_EXT_display_control"" name="VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME"/> @@ -6059,26 +6339,26 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value="0" name="VK_KHR_EXTENSION_94_SPEC_VERSION"/> <enum value=""VK_KHR_extension_94"" name="VK_KHR_EXTENSION_94_EXTENSION_NAME"/> </require> - </extension> - <extension name="VK_NV_sample_mask_override_coverage" number="95" type="device" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="vulkan"> + </extension> + <extension name="VK_NV_sample_mask_override_coverage" number="95" type="device" author="NV" contact="Piers Daniell @pdaniell" supported="vulkan"> <require> <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_geometry_shader_passthrough" number="96" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> + <extension name="VK_NV_geometry_shader_passthrough" number="96" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan"> <require> <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_viewport_array2" number="97" type="device" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="vulkan"> + <extension name="VK_NV_viewport_array2" number="97" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan"> <require> <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_NVX_multiview_per_view_attributes" number="98" type="device" author="NVIDIA" contact="Jeff Bolz @jbolz" supported="vulkan"> + <extension name="VK_NVX_multiview_per_view_attributes" number="98" type="device" author="NVX" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> <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"/> @@ -6088,7 +6368,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"/> </require> </extension> - <extension name="VK_NV_viewport_swizzle" number="99" type="device" author="NVIDIA" contact="Piers Daniell @pdaniell" supported="vulkan"> + <extension name="VK_NV_viewport_swizzle" number="99" type="device" author="NV" contact="Piers Daniell @pdaniell" supported="vulkan"> <require> <enum value="1" name="VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION"/> <enum value=""VK_NV_viewport_swizzle"" name="VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME"/> @@ -6099,7 +6379,7 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <type name="VkPipelineViewportSwizzleStateCreateFlagsNV"/> </require> </extension> - <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"> + <extension name="VK_EXT_discard_rectangles" number="100" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Piers Daniell @pdaniell" supported="vulkan"> <require> <enum value="1" name="VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION"/> <enum value=""VK_EXT_discard_rectangles"" name="VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME"/> @@ -6113,25 +6393,25 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkCmdSetDiscardRectangleEXT"/> </require> </extension> - <extension name="VK_NV_extension_101" number="101" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> + <extension name="VK_NV_extension_101" number="101" author="NV" contact="Daniel Koch @dgkoch" supported="disabled"> <require> <enum value="0" name="VK_NV_EXTENSION_101_SPEC_VERSION"/> <enum value=""VK_NV_extension_101"" name="VK_NV_EXTENSION_101_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_102" number="102" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> + <extension name="VK_NV_extension_102" number="102" author="NV" contact="Daniel Koch @dgkoch" supported="disabled"> <require> <enum value="0" name="VK_NV_EXTENSION_102_SPEC_VERSION"/> <enum value=""VK_NV_extension_102"" name="VK_NV_EXTENSION_102_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_103" number="103" author="NVIDIA" contact="Daniel Koch @dgkoch" supported="disabled"> + <extension name="VK_NV_extension_103" number="103" author="NV" contact="Daniel Koch @dgkoch" supported="disabled"> <require> <enum value="0" name="VK_NV_EXTENSION_103_SPEC_VERSION"/> <enum value=""VK_NV_extension_103"" name="VK_NV_EXTENSION_103_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_104" number="104" author="NVIDIA" contact="Mathias Schott @mschott" supported="disabled"> + <extension name="VK_NV_extension_104" number="104" author="NV" contact="Mathias Schott @mschott" supported="disabled"> <require> <enum value="0" name="VK_NV_EXTENSION_104_SPEC_VERSION"/> <enum value=""VK_NV_extension_104"" name="VK_NV_EXTENSION_104_EXTENSION_NAME"/> @@ -6208,28 +6488,57 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkGetSwapchainStatusKHR"/> </require> </extension> - <extension name="VK_KHR_extension_113" number="113" author="KHX" contact="Cass Everitt @casseveritt" supported="disabled"> + <extension name="VK_KHR_external_fence_capabilities" number="113" type="instance" author="KHR" requires="VK_KHR_get_physical_device_properties2" contact="Jesse Hall @jessehall" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_113_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_113"" name="VK_KHR_EXTENSION_113_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION"/> + <enum value=""VK_KHR_external_fence_capabilities"" name="VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR"/> + <enum name="VK_LUID_SIZE_KHR"/> + <type name="VkExternalFenceHandleTypeFlagsKHR"/> + <type name="VkExternalFenceHandleTypeFlagBitsKHR"/> + <type name="VkExternalFenceFeatureFlagsKHR"/> + <type name="VkExternalFenceFeatureFlagBitsKHR"/> + <type name="VkPhysicalDeviceExternalFenceInfoKHR"/> + <type name="VkExternalFencePropertiesKHR"/> + <type name="VkPhysicalDeviceIDPropertiesKHR"/> + <command name="vkGetPhysicalDeviceExternalFencePropertiesKHR"/> </require> </extension> - <extension name="VK_KHR_extension_114" number="114" author="KHX" contact="Cass Everitt @casseveritt" supported="disabled"> + <extension name="VK_KHR_external_fence" number="114" type="device" requires="VK_KHR_external_fence_capabilities" author="KHR" contact="Jesse Hall @jessehall" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_114_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_114"" name="VK_KHR_EXTENSION_114_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_EXTERNAL_FENCE_SPEC_VERSION"/> + <enum value=""VK_KHR_external_fence"" name="VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR"/> + <type name="VkFenceImportFlagsKHR"/> + <type name="VkFenceImportFlagBitsKHR"/> + <type name="VkExportFenceCreateInfoKHR"/> </require> </extension> - <extension name="VK_KHR_extension_115" number="115" author="KHX" contact="Cass Everitt @casseveritt" supported="disabled"> + <extension name="VK_KHR_external_fence_win32" number="115" type="device" requires="VK_KHR_external_fence" author="KHR" contact="Jesse Hall @jessehall" protect="VK_USE_PLATFORM_WIN32_KHR" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_115_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_115"" name="VK_KHR_EXTENSION_115_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION"/> + <enum value=""VK_KHR_external_fence_win32"" name="VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR"/> + <type name="VkImportFenceWin32HandleInfoKHR"/> + <type name="VkExportFenceWin32HandleInfoKHR"/> + <type name="VkFenceGetWin32HandleInfoKHR"/> + <command name="vkImportFenceWin32HandleKHR"/> + <command name="vkGetFenceWin32HandleKHR"/> </require> </extension> - <extension name="VK_KHR_extension_116" number="116" author="KHX" contact="Cass Everitt @casseveritt" supported="disabled"> + <extension name="VK_KHR_external_fence_fd" number="116" type="device" requires="VK_KHR_external_fence" author="KHR" contact="Jesse Hall @jessehall" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_116_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_116"" name="VK_KHR_EXTENSION_116_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION"/> + <enum value=""VK_KHR_external_fence_fd"" name="VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR"/> + <type name="VkImportFenceFdInfoKHR"/> + <type name="VkFenceGetFdInfoKHR"/> + <command name="vkImportFenceFdKHR"/> + <command name="vkGetFenceFdKHR"/> </require> </extension> <extension name="VK_KHR_extension_117" number="117" author="KHR" contact="Kenneth Benzie @kbenzie" supported="disabled"> @@ -6264,10 +6573,12 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <command name="vkGetPhysicalDeviceSurfaceFormats2KHR"/> </require> </extension> - <extension name="VK_KHR_variable_pointers" number="121" author="KHR" contact="John Kessenich @johnk" supported="disabled"> + <extension name="VK_KHR_variable_pointers" number="121" type="device" author="KHR" contact="Jesse Hall @jessehall" requires="VK_KHR_get_physical_device_properties2,VK_KHR_storage_buffer_storage_class" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_variable_pointers_SPEC_VERSION"/> - <enum value=""VK_KHR_variable_pointers"" name="VK_KHR_variable_pointers_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_VARIABLE_POINTERS_SPEC_VERSION"/> + <enum value=""VK_KHR_variable_pointers"" name="VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR"/> + <type name="VkPhysicalDeviceVariablePointerFeaturesKHR"/> </require> </extension> <extension name="VK_KHR_extension_122" number="122" author="KHR" contact="James Jones @cubanismo" supported="disabled"> @@ -6314,10 +6625,14 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_MESA_extension_127"" name="VK_MESA_EXTENSION_127_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_KHR_extension_128" number="128" author="KHR" contact="James Jones @cubanismo" supported="disabled"> + <extension name="VK_KHR_dedicated_allocation" number="128" type="device" author="KHR" contact="James Jones @cubanismo" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_128_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_128"" name="VK_KHR_EXTENSION_128_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION"/> + <enum value=""VK_KHR_dedicated_allocation"" name="VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR"/> + <type name="VkMemoryDedicatedRequirementsKHR"/> + <type name="VkMemoryDedicatedAllocateInfoKHR"/> </require> </extension> <extension name="VK_EXT_extension_129" number="129" author="LUNARG" contact="Mark Young @MarkY_LunarG" supported="disabled"> @@ -6332,22 +6647,28 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_KHR_extension_130"" name="VK_KHR_EXTENSION_130_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_KHR_extension_131" number="131" author="KHR" contact="Jeff Bolz @jbolz" supported="disabled"> + <extension name="VK_EXT_sampler_filter_minmax" number="131" type="device" author="NV" requires="VK_KHR_get_physical_device_properties2" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_131_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_131"" name="VK_KHR_EXTENSION_131_EXTENSION_NAME"/> + <enum value="1" name="VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION"/> + <enum value=""VK_EXT_sampler_filter_minmax"" name="VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT"/> + <enum bitpos="16" extends="VkFormatFeatureFlagBits" name="VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT" comment="Format can be used with min/max reduction filtering"/> + <type name="VkSamplerReductionModeEXT"/> + <type name="VkSamplerReductionModeCreateInfoEXT"/> + <type name="VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT"/> </require> </extension> - <extension name="VK_KHR_extension_132" number="132" author="KHR" contact="Jan-Harald Fredriksen @janharald" supported="disabled"> + <extension name="VK_KHR_storage_buffer_storage_class" number="132" type="device" author="KHR" contact="Alexander Galazin @debater" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_EXTENSION_132_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_132"" name="VK_KHR_EXTENSION_132_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION"/> + <enum value=""VK_KHR_storage_buffer_storage_class"" name="VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_AMD_extension_133" number="133" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled"> + <extension name="VK_AMD_gpu_shader_int16" number="133" type="device" author="AMD" contact="[email protected]" supported="vulkan"> <require> - <enum value="0" name="VK_AMD_EXTENSION_133_SPEC_VERSION"/> - <enum value=""VK_AMD_extension_133"" name="VK_AMD_EXTENSION_133_EXTENSION_NAME"/> + <enum value="1" name="VK_AMD_GPU_SHADER_INT16_SPEC_VERSION"/> + <enum value=""VK_AMD_gpu_shader_int16"" name="VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME"/> </require> </extension> <extension name="VK_AMD_extension_134" number="134" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled"> @@ -6428,10 +6749,23 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_KHR_extension_146"" name="VK_KHR_extension_146_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_KHR_extension_147" number="147" author="KHR" contact="Jason Ekstrand @jekstrand" supported="disabled"> + <extension name="VK_KHR_get_memory_requirements2" number="147" type="device" author="KHR" contact="Jason Ekstrand @jekstrand" supported="vulkan"> <require> - <enum value="0" name="VK_KHR_extension_147_SPEC_VERSION"/> - <enum value=""VK_KHR_extension_147"" name="VK_KHR_extension_147_EXTENSION_NAME"/> + <enum value="1" name="VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION"/> + <enum value=""VK_KHR_get_memory_requirements2"" name="VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR"/> + <enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR"/> + <enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR"/> + <type name="VkBufferMemoryRequirementsInfo2KHR"/> + <type name="VkImageMemoryRequirementsInfo2KHR"/> + <type name="VkImageSparseMemoryRequirementsInfo2KHR"/> + <type name="VkMemoryRequirements2KHR"/> + <type name="VkSparseImageMemoryRequirements2KHR"/> + <command name="vkGetImageMemoryRequirements2KHR"/> + <command name="vkGetBufferMemoryRequirements2KHR"/> + <command name="vkGetImageSparseMemoryRequirements2KHR"/> </require> </extension> <extension name="VK_EXT_extension_148" number="148" author="EXT" contact="Jason Ekstrand @jekstrand" supported="disabled"> @@ -6440,16 +6774,73 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_EXT_extension_148"" name="VK_KHR_EXTENSION_148_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_149" number="149" author="NV" contact="Jeff Bolz @jbolz" supported="disabled"> - <require> - <enum value="0" name="VK_NV_EXTENSION_149_SPEC_VERSION"/> - <enum value=""VK_NV_extension_149"" name="VK_NV_EXTENSION_149_EXTENSION_NAME"/> - </require> - </extension> - <extension name="VK_NV_extension_150" number="150" author="NV" contact="Jeff Bolz @jbolz" supported="disabled"> - <require> - <enum value="0" name="VK_NV_EXTENSION_150_SPEC_VERSION"/> - <enum value=""VK_NV_extension_150"" name="VK_NV_EXTENSION_150_EXTENSION_NAME"/> + <extension name="VK_EXT_blend_operation_advanced" number="149" type="device" author="NV" contact="Jeff Bolz @jbolz" supported="vulkan"> + <require> + <enum value="2" name="VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION"/> + <enum value=""VK_EXT_blend_operation_advanced"" name="VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"/> + <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"/> + <enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"/> + <type name="VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"/> + <type name="VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT"/> + <type name="VkPipelineColorBlendAdvancedStateCreateInfoEXT"/> + <type name="VkBlendOverlapEXT"/> + <enum offset="0" extends="VkBlendOp" name="VK_BLEND_OP_ZERO_EXT"/> + <enum offset="1" extends="VkBlendOp" name="VK_BLEND_OP_SRC_EXT"/> + <enum offset="2" extends="VkBlendOp" name="VK_BLEND_OP_DST_EXT"/> + <enum offset="3" extends="VkBlendOp" name="VK_BLEND_OP_SRC_OVER_EXT"/> + <enum offset="4" extends="VkBlendOp" name="VK_BLEND_OP_DST_OVER_EXT"/> + <enum offset="5" extends="VkBlendOp" name="VK_BLEND_OP_SRC_IN_EXT"/> + <enum offset="6" extends="VkBlendOp" name="VK_BLEND_OP_DST_IN_EXT"/> + <enum offset="7" extends="VkBlendOp" name="VK_BLEND_OP_SRC_OUT_EXT"/> + <enum offset="8" extends="VkBlendOp" name="VK_BLEND_OP_DST_OUT_EXT"/> + <enum offset="9" extends="VkBlendOp" name="VK_BLEND_OP_SRC_ATOP_EXT"/> + <enum offset="10" extends="VkBlendOp" name="VK_BLEND_OP_DST_ATOP_EXT"/> + <enum offset="11" extends="VkBlendOp" name="VK_BLEND_OP_XOR_EXT"/> + <enum offset="12" extends="VkBlendOp" name="VK_BLEND_OP_MULTIPLY_EXT"/> + <enum offset="13" extends="VkBlendOp" name="VK_BLEND_OP_SCREEN_EXT"/> + <enum offset="14" extends="VkBlendOp" name="VK_BLEND_OP_OVERLAY_EXT"/> + <enum offset="15" extends="VkBlendOp" name="VK_BLEND_OP_DARKEN_EXT"/> + <enum offset="16" extends="VkBlendOp" name="VK_BLEND_OP_LIGHTEN_EXT"/> + <enum offset="17" extends="VkBlendOp" name="VK_BLEND_OP_COLORDODGE_EXT"/> + <enum offset="18" extends="VkBlendOp" name="VK_BLEND_OP_COLORBURN_EXT"/> + <enum offset="19" extends="VkBlendOp" name="VK_BLEND_OP_HARDLIGHT_EXT"/> + <enum offset="20" extends="VkBlendOp" name="VK_BLEND_OP_SOFTLIGHT_EXT"/> + <enum offset="21" extends="VkBlendOp" name="VK_BLEND_OP_DIFFERENCE_EXT"/> + <enum offset="22" extends="VkBlendOp" name="VK_BLEND_OP_EXCLUSION_EXT"/> + <enum offset="23" extends="VkBlendOp" name="VK_BLEND_OP_INVERT_EXT"/> + <enum offset="24" extends="VkBlendOp" name="VK_BLEND_OP_INVERT_RGB_EXT"/> + <enum offset="25" extends="VkBlendOp" name="VK_BLEND_OP_LINEARDODGE_EXT"/> + <enum offset="26" extends="VkBlendOp" name="VK_BLEND_OP_LINEARBURN_EXT"/> + <enum offset="27" extends="VkBlendOp" name="VK_BLEND_OP_VIVIDLIGHT_EXT"/> + <enum offset="28" extends="VkBlendOp" name="VK_BLEND_OP_LINEARLIGHT_EXT"/> + <enum offset="29" extends="VkBlendOp" name="VK_BLEND_OP_PINLIGHT_EXT"/> + <enum offset="30" extends="VkBlendOp" name="VK_BLEND_OP_HARDMIX_EXT"/> + <enum offset="31" extends="VkBlendOp" name="VK_BLEND_OP_HSL_HUE_EXT"/> + <enum offset="32" extends="VkBlendOp" name="VK_BLEND_OP_HSL_SATURATION_EXT"/> + <enum offset="33" extends="VkBlendOp" name="VK_BLEND_OP_HSL_COLOR_EXT"/> + <enum offset="34" extends="VkBlendOp" name="VK_BLEND_OP_HSL_LUMINOSITY_EXT"/> + <enum offset="35" extends="VkBlendOp" name="VK_BLEND_OP_PLUS_EXT"/> + <enum offset="36" extends="VkBlendOp" name="VK_BLEND_OP_PLUS_CLAMPED_EXT"/> + <enum offset="37" extends="VkBlendOp" name="VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT"/> + <enum offset="38" extends="VkBlendOp" name="VK_BLEND_OP_PLUS_DARKER_EXT"/> + <enum offset="39" extends="VkBlendOp" name="VK_BLEND_OP_MINUS_EXT"/> + <enum offset="40" extends="VkBlendOp" name="VK_BLEND_OP_MINUS_CLAMPED_EXT"/> + <enum offset="41" extends="VkBlendOp" name="VK_BLEND_OP_CONTRAST_EXT"/> + <enum offset="42" extends="VkBlendOp" name="VK_BLEND_OP_INVERT_OVG_EXT"/> + <enum offset="43" extends="VkBlendOp" name="VK_BLEND_OP_RED_EXT"/> + <enum offset="44" extends="VkBlendOp" name="VK_BLEND_OP_GREEN_EXT"/> + <enum offset="45" extends="VkBlendOp" name="VK_BLEND_OP_BLUE_EXT"/> + <enum bitpos="19" extends="VkAccessFlagBits" name="VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"/> + </require> + </extension> + <extension name="VK_NV_fragment_coverage_to_color" number="150" type="device" author="NV" contact="Jeff Bolz @jbolz" supported="vulkan"> + <require> + <enum value="1" name="VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION"/> + <enum value=""VK_NV_fragment_coverage_to_color"" name="VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV"/> + <type name="VkPipelineCoverageToColorStateCreateFlagsNV"/> + <type name="VkPipelineCoverageToColorStateCreateInfoNV"/> </require> </extension> <extension name="VK_NV_extension_151" number="151" author="NV" contact="Jeff Bolz @jbolz" supported="disabled"> @@ -6464,16 +6855,21 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_NV_extension_152"" name="VK_NV_EXTENSION_152_EXTENSION_NAME"/> </require> </extension> - <extension name="VK_NV_extension_153" number="153" author="NV" contact="Jeff Bolz @jbolz" supported="disabled"> + <extension name="VK_NV_framebuffer_mixed_samples" number="153" type="device" author="NV" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> - <enum value="0" name="VK_NV_EXTENSION_153_SPEC_VERSION"/> - <enum value=""VK_NV_extension_153"" name="VK_NV_EXTENSION_153_EXTENSION_NAME"/> + <enum value="1" name="VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION"/> + <enum value=""VK_NV_framebuffer_mixed_samples"" name="VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME"/> + <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV"/> + <type name="VkPipelineCoverageModulationStateCreateInfoNV"/> + <type name="VkPipelineCoverageModulationStateCreateFlagsNV"/> + <type name="VkCoverageModulationModeNV"/> </require> </extension> - <extension name="VK_NV_extension_154" number="154" author="NV" contact="Jeff Bolz @jbolz" supported="disabled"> + <extension name="VK_NV_fill_rectangle" number="154" type="device" author="NV" contact="Jeff Bolz @jbolz" supported="vulkan"> <require> - <enum value="0" name="VK_NV_EXTENSION_154_SPEC_VERSION"/> - <enum value=""VK_NV_extension_154"" name="VK_NV_EXTENSION_154_EXTENSION_NAME"/> + <enum value="1" name="VK_NV_FILL_RECTANGLE_SPEC_VERSION"/> + <enum value=""VK_NV_fill_rectangle"" name="VK_NV_FILL_RECTANGLE_EXTENSION_NAME"/> + <enum offset="0" extends="VkPolygonMode" name="VK_POLYGON_MODE_FILL_RECTANGLE_NV"/> </require> </extension> <extension name="VK_NV_extension_155" number="155" author="NV" contact="Jeff Bolz @jbolz" supported="disabled"> @@ -6488,5 +6884,29 @@ maintained in the master branch of the Khronos Vulkan GitHub project. <enum value=""VK_NV_extension_156"" name="VK_NV_EXTENSION_156_EXTENSION_NAME"/> </require> </extension> + <extension name="VK_KHR_extension_157" number="157" author="KHR" contact="Andrew Garrard @fluppeteer" supported="disabled"> + <require> + <enum value="0" name="VK_KHR_EXTENSION_157_SPEC_VERSION"/> + <enum value=""VK_KHR_extension_157"" name="VK_KHR_EXTENSION_157_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_KHR_extension_158" number="158" author="KHR" contact="Tobias Hector @tobias" supported="disabled"> + <require> + <enum value="0" name="VK_KHR_EXTENSION_158_SPEC_VERSION"/> + <enum value=""VK_KHR_extension_158"" name="VK_KHR_EXTENSION_158_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_EXT_extension_159" number="159" author="EXT" contact="Chad Versace @chadversary" supported="disabled"> + <require> + <enum value="0" name="VK_EXT_EXTENSION_159_SPEC_VERSION"/> + <enum value=""VK_EXT_extension_159"" name="VK_EXT_EXTENSION_159_EXTENSION_NAME"/> + </require> + </extension> + <extension name="VK_EXT_extension_160" number="160" author="EXT" contact="Mark Young @MarkY_LunarG" supported="disabled"> + <require> + <enum value="0" name="VK_EXT_EXTENSION_160_SPEC_VERSION"/> + <enum value=""VK_EXT_extension_160"" name="VK_EXT_EXTENSION_160_EXTENSION_NAME"/> + </require> + </extension> </extensions> </registry> |