From 2c4bbf3f049e561125501baab93c79d149d49394 Mon Sep 17 00:00:00 2001 From: Mark Young Date: Fri, 7 Jul 2017 07:59:56 -0600 Subject: header: Update to 1.0.54 Vulkan release Update the headers and xml file with the latest spec changes for Vulkan 1.0.54. Also, make corresponding loader and layer changes to support the new extensions. Change-Id: I11273c5e3e828743f904e4f0b4b2f2c3a7804df0 --- include/vulkan/vulkan.h | 1028 +- include/vulkan/vulkan.hpp | 11726 ++++++++++++--------- layers/linux/VkLayer_core_validation.json | 2 +- layers/linux/VkLayer_object_tracker.json | 2 +- layers/linux/VkLayer_parameter_validation.json | 2 +- layers/linux/VkLayer_standard_validation.json | 2 +- layers/linux/VkLayer_threading.json | 2 +- layers/linux/VkLayer_unique_objects.json | 2 +- layers/object_tracker.cpp | 447 +- layers/parameter_validation.cpp | 585 +- layers/vk_validation_error_database.txt | 543 +- layers/vk_validation_error_messages.h | 628 +- layers/windows/VkLayer_core_validation.json | 2 +- layers/windows/VkLayer_object_tracker.json | 2 +- layers/windows/VkLayer_parameter_validation.json | 2 +- layers/windows/VkLayer_standard_validation.json | 2 +- layers/windows/VkLayer_threading.json | 2 +- layers/windows/VkLayer_unique_objects.json | 2 +- loader/extension_manual.c | 148 +- loader/extension_manual.h | 24 + scripts/helper_file_generator.py | 7 +- scripts/loader_extension_generator.py | 5 +- scripts/unique_objects_generator.py | 3 + scripts/vk.xml | 849 +- scripts/vuid_mapping.py | 102 +- 25 files changed, 9625 insertions(+), 6494 deletions(-) diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h index 3255e7d7..16434fef 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 53 +#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), @@ -257,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, @@ -300,13 +305,29 @@ 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, @@ -4084,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" @@ -4107,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" @@ -4222,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" @@ -4261,6 +4813,101 @@ 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) @@ -4988,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) diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index a6df8741..ef8eed3b 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -33,7 +33,7 @@ # include # include #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -static_assert( VK_HEADER_VERSION == 53 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 54 , "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -453,7 +453,7 @@ namespace vk eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT, eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV, eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, - eErrorInvalidExternalHandleKHX = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX + eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR }; VULKAN_HPP_INLINE std::string to_string(Result value) @@ -486,7 +486,7 @@ namespace vk case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT"; case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV"; case Result::eErrorOutOfPoolMemoryKHR: return "ErrorOutOfPoolMemoryKHR"; - case Result::eErrorInvalidExternalHandleKHX: return "ErrorInvalidExternalHandleKHX"; + case Result::eErrorInvalidExternalHandleKHR: return "ErrorInvalidExternalHandleKHR"; default: return "invalid"; } } @@ -723,13 +723,13 @@ namespace vk OutOfPoolMemoryKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {} }; - class InvalidExternalHandleKHXError : public SystemError + class InvalidExternalHandleKHRError : public SystemError { public: - InvalidExternalHandleKHXError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHX ), message ) {} - InvalidExternalHandleKHXError( char const * message ) - : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHX ), message ) {} + InvalidExternalHandleKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHR ), message ) {} + InvalidExternalHandleKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHR ), message ) {} }; VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) @@ -756,7 +756,7 @@ namespace vk case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError ( message ); case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message ); case Result::eErrorOutOfPoolMemoryKHR: throw OutOfPoolMemoryKHRError ( message ); - case Result::eErrorInvalidExternalHandleKHX: throw InvalidExternalHandleKHXError ( message ); + case Result::eErrorInvalidExternalHandleKHR: throw InvalidExternalHandleKHRError ( message ); default: throw SystemError( make_error_code( result ) ); } } @@ -6476,28 +6476,33 @@ namespace vk eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, ePhysicalDeviceGroupPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX, eDeviceGroupDeviceCreateInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX, - ePhysicalDeviceExternalImageFormatInfoKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX, - eExternalImageFormatPropertiesKHX = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX, - ePhysicalDeviceExternalBufferInfoKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX, - eExternalBufferPropertiesKHX = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX, - ePhysicalDeviceIdPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX, - eExternalMemoryBufferCreateInfoKHX = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX, - eExternalMemoryImageCreateInfoKHX = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX, - eExportMemoryAllocateInfoKHX = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX, - eImportMemoryWin32HandleInfoKHX = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX, - eExportMemoryWin32HandleInfoKHX = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX, - eMemoryWin32HandlePropertiesKHX = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX, - eImportMemoryFdInfoKHX = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX, - eMemoryFdPropertiesKHX = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX, - eWin32KeyedMutexAcquireReleaseInfoKHX = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX, - ePhysicalDeviceExternalSemaphoreInfoKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX, - eExternalSemaphorePropertiesKHX = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX, - eExportSemaphoreCreateInfoKHX = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX, - eImportSemaphoreWin32HandleInfoKHX = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX, - eExportSemaphoreWin32HandleInfoKHX = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX, - eD3D12FenceSubmitInfoKHX = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX, - eImportSemaphoreFdInfoKHX = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX, + ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR, + eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR, + ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR, + eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR, + ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, + eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR, + eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR, + eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, + eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, + eMemoryGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, + eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, + eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, + eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, + eWin32KeyedMutexAcquireReleaseInfoKHR = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, + ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, + eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, + eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR, + eImportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + eExportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, + eSemaphoreGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, + eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, + eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, + ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX, @@ -6519,13 +6524,29 @@ namespace vk ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT, eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, + ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, + eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR, + eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR, + eImportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, + eExportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, + eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, + eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, + eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, + ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR, eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK, eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, + eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, + eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, + eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, + eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, + eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR, + eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, + eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR, ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, @@ -10313,24 +10334,91 @@ namespace vk }; static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceIDPropertiesKHX + struct PhysicalDeviceVariablePointerFeaturesKHR { - operator const VkPhysicalDeviceIDPropertiesKHX&() const + PhysicalDeviceVariablePointerFeaturesKHR( Bool32 variablePointersStorageBuffer_ = 0, Bool32 variablePointers_ = 0 ) + : sType( StructureType::ePhysicalDeviceVariablePointerFeaturesKHR ) + , pNext( nullptr ) + , variablePointersStorageBuffer( variablePointersStorageBuffer_ ) + , variablePointers( variablePointers_ ) + { + } + + PhysicalDeviceVariablePointerFeaturesKHR( VkPhysicalDeviceVariablePointerFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) ); + } + + PhysicalDeviceVariablePointerFeaturesKHR& operator=( VkPhysicalDeviceVariablePointerFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) ); + return *this; + } + PhysicalDeviceVariablePointerFeaturesKHR& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceVariablePointerFeaturesKHR& setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) + { + variablePointersStorageBuffer = variablePointersStorageBuffer_; + return *this; + } + + PhysicalDeviceVariablePointerFeaturesKHR& setVariablePointers( Bool32 variablePointers_ ) + { + variablePointers = variablePointers_; + return *this; + } + + operator const VkPhysicalDeviceVariablePointerFeaturesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceVariablePointerFeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) + && ( variablePointers == rhs.variablePointers ); + } + + bool operator!=( PhysicalDeviceVariablePointerFeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + Bool32 variablePointersStorageBuffer; + Bool32 variablePointers; + }; + static_assert( sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) == sizeof( VkPhysicalDeviceVariablePointerFeaturesKHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceIDPropertiesKHR + { + operator const VkPhysicalDeviceIDPropertiesKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceIDPropertiesKHX const& rhs ) const + bool operator==( PhysicalDeviceIDPropertiesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE_KHX * sizeof( uint8_t ) ) == 0 ) + && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE_KHR * sizeof( uint8_t ) ) == 0 ) + && ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ); } - bool operator!=( PhysicalDeviceIDPropertiesKHX const& rhs ) const + bool operator!=( PhysicalDeviceIDPropertiesKHR const& rhs ) const { return !operator==( rhs ); } @@ -10342,16 +10430,17 @@ namespace vk void* pNext; uint8_t deviceUUID[VK_UUID_SIZE]; uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE_KHX]; + uint8_t deviceLUID[VK_LUID_SIZE_KHR]; + uint32_t deviceNodeMask; Bool32 deviceLUIDValid; }; - static_assert( sizeof( PhysicalDeviceIDPropertiesKHX ) == sizeof( VkPhysicalDeviceIDPropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceIDPropertiesKHR ) == sizeof( VkPhysicalDeviceIDPropertiesKHR ), "struct and wrapper have different size!" ); -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct ExportMemoryWin32HandleInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportMemoryWin32HandleInfoKHR { - ExportMemoryWin32HandleInfoKHX( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eExportMemoryWin32HandleInfoKHX ) + ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eExportMemoryWin32HandleInfoKHR ) , pNext( nullptr ) , pAttributes( pAttributes_ ) , dwAccess( dwAccess_ ) @@ -10359,46 +10448,46 @@ namespace vk { } - ExportMemoryWin32HandleInfoKHX( VkExportMemoryWin32HandleInfoKHX const & rhs ) + ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHX ) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); } - ExportMemoryWin32HandleInfoKHX& operator=( VkExportMemoryWin32HandleInfoKHX const & rhs ) + ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHX ) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); return *this; } - ExportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ ) + ExportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExportMemoryWin32HandleInfoKHX& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + ExportMemoryWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) { pAttributes = pAttributes_; return *this; } - ExportMemoryWin32HandleInfoKHX& setDwAccess( DWORD dwAccess_ ) + ExportMemoryWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) { dwAccess = dwAccess_; return *this; } - ExportMemoryWin32HandleInfoKHX& setName( LPCWSTR name_ ) + ExportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) { name = name_; return *this; } - operator const VkExportMemoryWin32HandleInfoKHX&() const + operator const VkExportMemoryWin32HandleInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExportMemoryWin32HandleInfoKHX const& rhs ) const + bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -10407,7 +10496,7 @@ namespace vk && ( name == rhs.name ); } - bool operator!=( ExportMemoryWin32HandleInfoKHX const& rhs ) const + bool operator!=( ExportMemoryWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -10421,25 +10510,25 @@ namespace vk DWORD dwAccess; LPCWSTR name; }; - static_assert( sizeof( ExportMemoryWin32HandleInfoKHX ) == sizeof( VkExportMemoryWin32HandleInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct MemoryWin32HandlePropertiesKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct MemoryWin32HandlePropertiesKHR { - operator const VkMemoryWin32HandlePropertiesKHX&() const + operator const VkMemoryWin32HandlePropertiesKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( MemoryWin32HandlePropertiesKHX const& rhs ) const + bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); } - bool operator!=( MemoryWin32HandlePropertiesKHX const& rhs ) const + bool operator!=( MemoryWin32HandlePropertiesKHR const& rhs ) const { return !operator==( rhs ); } @@ -10451,24 +10540,24 @@ namespace vk void* pNext; uint32_t memoryTypeBits; }; - static_assert( sizeof( MemoryWin32HandlePropertiesKHX ) == sizeof( VkMemoryWin32HandlePropertiesKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - struct MemoryFdPropertiesKHX + struct MemoryFdPropertiesKHR { - operator const VkMemoryFdPropertiesKHX&() const + operator const VkMemoryFdPropertiesKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( MemoryFdPropertiesKHX const& rhs ) const + bool operator==( MemoryFdPropertiesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); } - bool operator!=( MemoryFdPropertiesKHX const& rhs ) const + bool operator!=( MemoryFdPropertiesKHR const& rhs ) const { return !operator==( rhs ); } @@ -10480,13 +10569,13 @@ namespace vk void* pNext; uint32_t memoryTypeBits; }; - static_assert( sizeof( MemoryFdPropertiesKHX ) == sizeof( VkMemoryFdPropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - struct Win32KeyedMutexAcquireReleaseInfoKHX + struct Win32KeyedMutexAcquireReleaseInfoKHR { - Win32KeyedMutexAcquireReleaseInfoKHX( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeouts_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) - : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoKHX ) + Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeouts_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) + : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR ) , pNext( nullptr ) , acquireCount( acquireCount_ ) , pAcquireSyncs( pAcquireSyncs_ ) @@ -10498,70 +10587,70 @@ namespace vk { } - Win32KeyedMutexAcquireReleaseInfoKHX( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs ) + Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHX ) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); } - Win32KeyedMutexAcquireReleaseInfoKHX& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs ) + Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHX ) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPNext( const void* pNext_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setAcquireCount( uint32_t acquireCount_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setAcquireCount( uint32_t acquireCount_ ) { acquireCount = acquireCount_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) { pAcquireSyncs = pAcquireSyncs_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) { pAcquireKeys = pAcquireKeys_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ ) { pAcquireTimeouts = pAcquireTimeouts_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setReleaseCount( uint32_t releaseCount_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setReleaseCount( uint32_t releaseCount_ ) { releaseCount = releaseCount_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) { pReleaseSyncs = pReleaseSyncs_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) { pReleaseKeys = pReleaseKeys_; return *this; } - operator const VkWin32KeyedMutexAcquireReleaseInfoKHX&() const + operator const VkWin32KeyedMutexAcquireReleaseInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( Win32KeyedMutexAcquireReleaseInfoKHX const& rhs ) const + bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -10574,7 +10663,7 @@ namespace vk && ( pReleaseKeys == rhs.pReleaseKeys ); } - bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHX const& rhs ) const + bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -10592,14 +10681,14 @@ namespace vk const DeviceMemory* pReleaseSyncs; const uint64_t* pReleaseKeys; }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHX ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct ExportSemaphoreWin32HandleInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportSemaphoreWin32HandleInfoKHR { - ExportSemaphoreWin32HandleInfoKHX( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eExportSemaphoreWin32HandleInfoKHX ) + ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eExportSemaphoreWin32HandleInfoKHR ) , pNext( nullptr ) , pAttributes( pAttributes_ ) , dwAccess( dwAccess_ ) @@ -10607,46 +10696,46 @@ namespace vk { } - ExportSemaphoreWin32HandleInfoKHX( VkExportSemaphoreWin32HandleInfoKHX const & rhs ) + ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHX ) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); } - ExportSemaphoreWin32HandleInfoKHX& operator=( VkExportSemaphoreWin32HandleInfoKHX const & rhs ) + ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHX ) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); return *this; } - ExportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ ) + ExportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExportSemaphoreWin32HandleInfoKHX& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + ExportSemaphoreWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) { pAttributes = pAttributes_; return *this; } - ExportSemaphoreWin32HandleInfoKHX& setDwAccess( DWORD dwAccess_ ) + ExportSemaphoreWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) { dwAccess = dwAccess_; return *this; } - ExportSemaphoreWin32HandleInfoKHX& setName( LPCWSTR name_ ) + ExportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) { name = name_; return *this; } - operator const VkExportSemaphoreWin32HandleInfoKHX&() const + operator const VkExportSemaphoreWin32HandleInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExportSemaphoreWin32HandleInfoKHX const& rhs ) const + bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -10655,7 +10744,7 @@ namespace vk && ( name == rhs.name ); } - bool operator!=( ExportSemaphoreWin32HandleInfoKHX const& rhs ) const + bool operator!=( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -10669,14 +10758,14 @@ namespace vk DWORD dwAccess; LPCWSTR name; }; - static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHX ) == sizeof( VkExportSemaphoreWin32HandleInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct D3D12FenceSubmitInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct D3D12FenceSubmitInfoKHR { - D3D12FenceSubmitInfoKHX( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) - : sType( StructureType::eD3D12FenceSubmitInfoKHX ) + D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) + : sType( StructureType::eD3D12FenceSubmitInfoKHR ) , pNext( nullptr ) , waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) @@ -10685,52 +10774,52 @@ namespace vk { } - D3D12FenceSubmitInfoKHX( VkD3D12FenceSubmitInfoKHX const & rhs ) + D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHX ) ); + memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); } - D3D12FenceSubmitInfoKHX& operator=( VkD3D12FenceSubmitInfoKHX const & rhs ) + D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHX ) ); + memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); return *this; } - D3D12FenceSubmitInfoKHX& setPNext( const void* pNext_ ) + D3D12FenceSubmitInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - D3D12FenceSubmitInfoKHX& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) + D3D12FenceSubmitInfoKHR& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) { waitSemaphoreValuesCount = waitSemaphoreValuesCount_; return *this; } - D3D12FenceSubmitInfoKHX& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ ) + D3D12FenceSubmitInfoKHR& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ ) { pWaitSemaphoreValues = pWaitSemaphoreValues_; return *this; } - D3D12FenceSubmitInfoKHX& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) + D3D12FenceSubmitInfoKHR& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) { signalSemaphoreValuesCount = signalSemaphoreValuesCount_; return *this; } - D3D12FenceSubmitInfoKHX& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ ) + D3D12FenceSubmitInfoKHR& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ ) { pSignalSemaphoreValues = pSignalSemaphoreValues_; return *this; } - operator const VkD3D12FenceSubmitInfoKHX&() const + operator const VkD3D12FenceSubmitInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( D3D12FenceSubmitInfoKHX const& rhs ) const + bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -10740,7 +10829,7 @@ namespace vk && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); } - bool operator!=( D3D12FenceSubmitInfoKHX const& rhs ) const + bool operator!=( D3D12FenceSubmitInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -10755,8 +10844,85 @@ namespace vk uint32_t signalSemaphoreValuesCount; const uint64_t* pSignalSemaphoreValues; }; - static_assert( sizeof( D3D12FenceSubmitInfoKHX ) == sizeof( VkD3D12FenceSubmitInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportFenceWin32HandleInfoKHR + { + ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eExportFenceWin32HandleInfoKHR ) + , pNext( nullptr ) + , pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) + { + } + + ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); + } + + ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); + return *this; + } + ExportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportFenceWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + { + pAttributes = pAttributes_; + return *this; + } + + ExportFenceWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) + { + dwAccess = dwAccess_; + return *this; + } + + ExportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkExportFenceWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pAttributes == rhs.pAttributes ) + && ( dwAccess == rhs.dwAccess ) + && ( name == rhs.name ); + } + + bool operator!=( ExportFenceWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; + }; + static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct PhysicalDeviceMultiviewFeaturesKHX { @@ -12224,21 +12390,74 @@ namespace vk }; static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" ); - struct TextureLODGatherFormatPropertiesAMD + struct PhysicalDevice16BitStorageFeaturesKHR { - operator const VkTextureLODGatherFormatPropertiesAMD&() const + PhysicalDevice16BitStorageFeaturesKHR( Bool32 storageBuffer16BitAccess_ = 0, Bool32 uniformAndStorageBuffer16BitAccess_ = 0, Bool32 storagePushConstant16_ = 0, Bool32 storageInputOutput16_ = 0 ) + : sType( StructureType::ePhysicalDevice16BitStorageFeaturesKHR ) + , pNext( nullptr ) + , storageBuffer16BitAccess( storageBuffer16BitAccess_ ) + , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) + , storagePushConstant16( storagePushConstant16_ ) + , storageInputOutput16( storageInputOutput16_ ) { - return *reinterpret_cast(this); } - bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const + PhysicalDevice16BitStorageFeaturesKHR( VkPhysicalDevice16BitStorageFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeaturesKHR ) ); + } + + PhysicalDevice16BitStorageFeaturesKHR& operator=( VkPhysicalDevice16BitStorageFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeaturesKHR ) ); + return *this; + } + PhysicalDevice16BitStorageFeaturesKHR& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDevice16BitStorageFeaturesKHR& setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) + { + storageBuffer16BitAccess = storageBuffer16BitAccess_; + return *this; + } + + PhysicalDevice16BitStorageFeaturesKHR& setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) + { + uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; + return *this; + } + + PhysicalDevice16BitStorageFeaturesKHR& setStoragePushConstant16( Bool32 storagePushConstant16_ ) + { + storagePushConstant16 = storagePushConstant16_; + return *this; + } + + PhysicalDevice16BitStorageFeaturesKHR& setStorageInputOutput16( Bool32 storageInputOutput16_ ) + { + storageInputOutput16 = storageInputOutput16_; + return *this; + } + + operator const VkPhysicalDevice16BitStorageFeaturesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDevice16BitStorageFeaturesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); + && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) + && ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) + && ( storagePushConstant16 == rhs.storagePushConstant16 ) + && ( storageInputOutput16 == rhs.storageInputOutput16 ); } - bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const + bool operator!=( PhysicalDevice16BitStorageFeaturesKHR const& rhs ) const { return !operator==( rhs ); } @@ -12248,70 +12467,57 @@ namespace vk public: void* pNext; - Bool32 supportsTextureGatherLODBiasAMD; + Bool32 storageBuffer16BitAccess; + Bool32 uniformAndStorageBuffer16BitAccess; + Bool32 storagePushConstant16; + Bool32 storageInputOutput16; }; - static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDevice16BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice16BitStorageFeaturesKHR ), "struct and wrapper have different size!" ); - struct PipelineCoverageToColorStateCreateInfoNV + struct BufferMemoryRequirementsInfo2KHR { - PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 ) - : sType( StructureType::ePipelineCoverageToColorStateCreateInfoNV ) + BufferMemoryRequirementsInfo2KHR( Buffer buffer_ = Buffer() ) + : sType( StructureType::eBufferMemoryRequirementsInfo2KHR ) , pNext( nullptr ) - , flags( flags_ ) - , coverageToColorEnable( coverageToColorEnable_ ) - , coverageToColorLocation( coverageToColorLocation_ ) + , buffer( buffer_ ) { } - PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) + BufferMemoryRequirementsInfo2KHR( VkBufferMemoryRequirementsInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); + memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2KHR ) ); } - PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) + BufferMemoryRequirementsInfo2KHR& operator=( VkBufferMemoryRequirementsInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); + memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2KHR ) ); return *this; } - PipelineCoverageToColorStateCreateInfoNV& setPNext( const void* pNext_ ) + BufferMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PipelineCoverageToColorStateCreateInfoNV& setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) - { - flags = flags_; - return *this; - } - - PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) - { - coverageToColorEnable = coverageToColorEnable_; - return *this; - } - - PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) + BufferMemoryRequirementsInfo2KHR& setBuffer( Buffer buffer_ ) { - coverageToColorLocation = coverageToColorLocation_; + buffer = buffer_; return *this; } - operator const VkPipelineCoverageToColorStateCreateInfoNV&() const + operator const VkBufferMemoryRequirementsInfo2KHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const + bool operator==( BufferMemoryRequirementsInfo2KHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( coverageToColorEnable == rhs.coverageToColorEnable ) - && ( coverageToColorLocation == rhs.coverageToColorLocation ); + && ( buffer == rhs.buffer ); } - bool operator!=( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const + bool operator!=( BufferMemoryRequirementsInfo2KHR const& rhs ) const { return !operator==( rhs ); } @@ -12321,28 +12527,54 @@ namespace vk public: const void* pNext; - PipelineCoverageToColorStateCreateFlagsNV flags; - Bool32 coverageToColorEnable; - uint32_t coverageToColorLocation; + Buffer buffer; }; - static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); + static_assert( sizeof( BufferMemoryRequirementsInfo2KHR ) == sizeof( VkBufferMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT + struct ImageMemoryRequirementsInfo2KHR { - operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const + ImageMemoryRequirementsInfo2KHR( Image image_ = Image() ) + : sType( StructureType::eImageMemoryRequirementsInfo2KHR ) + , pNext( nullptr ) + , image( image_ ) { - return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const + ImageMemoryRequirementsInfo2KHR( VkImageMemoryRequirementsInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2KHR ) ); + } + + ImageMemoryRequirementsInfo2KHR& operator=( VkImageMemoryRequirementsInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2KHR ) ); + return *this; + } + ImageMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageMemoryRequirementsInfo2KHR& setImage( Image image_ ) + { + image = image_; + return *this; + } + + operator const VkImageMemoryRequirementsInfo2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageMemoryRequirementsInfo2KHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) - && ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); + && ( image == rhs.image ); } - bool operator!=( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const + bool operator!=( ImageMemoryRequirementsInfo2KHR const& rhs ) const { return !operator==( rhs ); } @@ -12351,56 +12583,55 @@ namespace vk StructureType sType; public: - void* pNext; - Bool32 filterMinmaxSingleComponentFormats; - Bool32 filterMinmaxImageComponentMapping; + const void* pNext; + Image image; }; - static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImageMemoryRequirementsInfo2KHR ) == sizeof( VkImageMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT + struct ImageSparseMemoryRequirementsInfo2KHR { - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 ) - : sType( StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT ) + ImageSparseMemoryRequirementsInfo2KHR( Image image_ = Image() ) + : sType( StructureType::eImageSparseMemoryRequirementsInfo2KHR ) , pNext( nullptr ) - , advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) + , image( image_ ) { } - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) + ImageSparseMemoryRequirementsInfo2KHR( VkImageSparseMemoryRequirementsInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); + memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2KHR ) ); } - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) + ImageSparseMemoryRequirementsInfo2KHR& operator=( VkImageSparseMemoryRequirementsInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); + memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2KHR ) ); return *this; } - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setPNext( void* pNext_ ) + ImageSparseMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) + ImageSparseMemoryRequirementsInfo2KHR& setImage( Image image_ ) { - advancedBlendCoherentOperations = advancedBlendCoherentOperations_; + image = image_; return *this; } - operator const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&() const + operator const VkImageSparseMemoryRequirementsInfo2KHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const + bool operator==( ImageSparseMemoryRequirementsInfo2KHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); + && ( image == rhs.image ); } - bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const + bool operator!=( ImageSparseMemoryRequirementsInfo2KHR const& rhs ) const { return !operator==( rhs ); } @@ -12409,31 +12640,26 @@ namespace vk StructureType sType; public: - void* pNext; - Bool32 advancedBlendCoherentOperations; + const void* pNext; + Image image; }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImageSparseMemoryRequirementsInfo2KHR ) == sizeof( VkImageSparseMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT + struct MemoryRequirements2KHR { - operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const + operator const VkMemoryRequirements2KHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const + bool operator==( MemoryRequirements2KHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) - && ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) - && ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) - && ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) - && ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) - && ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); + && ( memoryRequirements == rhs.memoryRequirements ); } - bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const + bool operator!=( MemoryRequirements2KHR const& rhs ) const { return !operator==( rhs ); } @@ -12443,105 +12669,121 @@ namespace vk public: void* pNext; - uint32_t advancedBlendMaxColorAttachments; - Bool32 advancedBlendIndependentBlend; - Bool32 advancedBlendNonPremultipliedSrcColor; - Bool32 advancedBlendNonPremultipliedDstColor; - Bool32 advancedBlendCorrelatedOverlap; - Bool32 advancedBlendAllOperations; + MemoryRequirements memoryRequirements; }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); + static_assert( sizeof( MemoryRequirements2KHR ) == sizeof( VkMemoryRequirements2KHR ), "struct and wrapper have different size!" ); - enum class SubpassContents + struct MemoryDedicatedRequirementsKHR { - eInline = VK_SUBPASS_CONTENTS_INLINE, - eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS + operator const VkMemoryDedicatedRequirementsKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryDedicatedRequirementsKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) + && ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); + } + + bool operator!=( MemoryDedicatedRequirementsKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + Bool32 prefersDedicatedAllocation; + Bool32 requiresDedicatedAllocation; }; + static_assert( sizeof( MemoryDedicatedRequirementsKHR ) == sizeof( VkMemoryDedicatedRequirementsKHR ), "struct and wrapper have different size!" ); - struct PresentInfoKHR + struct MemoryDedicatedAllocateInfoKHR { - PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t swapchainCount_ = 0, const SwapchainKHR* pSwapchains_ = nullptr, const uint32_t* pImageIndices_ = nullptr, Result* pResults_ = nullptr ) - : sType( StructureType::ePresentInfoKHR ) + MemoryDedicatedAllocateInfoKHR( Image image_ = Image(), Buffer buffer_ = Buffer() ) + : sType( StructureType::eMemoryDedicatedAllocateInfoKHR ) , pNext( nullptr ) - , waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , swapchainCount( swapchainCount_ ) - , pSwapchains( pSwapchains_ ) - , pImageIndices( pImageIndices_ ) - , pResults( pResults_ ) + , image( image_ ) + , buffer( buffer_ ) { } - PresentInfoKHR( VkPresentInfoKHR const & rhs ) + MemoryDedicatedAllocateInfoKHR( VkMemoryDedicatedAllocateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); + memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfoKHR ) ); } - PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) + MemoryDedicatedAllocateInfoKHR& operator=( VkMemoryDedicatedAllocateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); + memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfoKHR ) ); return *this; } - PresentInfoKHR& setPNext( const void* pNext_ ) + MemoryDedicatedAllocateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) + MemoryDedicatedAllocateInfoKHR& setImage( Image image_ ) { - waitSemaphoreCount = waitSemaphoreCount_; + image = image_; return *this; } - PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) + MemoryDedicatedAllocateInfoKHR& setBuffer( Buffer buffer_ ) { - pWaitSemaphores = pWaitSemaphores_; + buffer = buffer_; return *this; } - PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ ) + operator const VkMemoryDedicatedAllocateInfoKHR&() const { - swapchainCount = swapchainCount_; - return *this; + return *reinterpret_cast(this); } - PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ ) + bool operator==( MemoryDedicatedAllocateInfoKHR const& rhs ) const { - pSwapchains = pSwapchains_; - return *this; + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( image == rhs.image ) + && ( buffer == rhs.buffer ); } - PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ ) + bool operator!=( MemoryDedicatedAllocateInfoKHR const& rhs ) const { - pImageIndices = pImageIndices_; - return *this; + return !operator==( rhs ); } - PresentInfoKHR& setPResults( Result* pResults_ ) - { - pResults = pResults_; - return *this; - } + private: + StructureType sType; - operator const VkPresentInfoKHR&() const + public: + const void* pNext; + Image image; + Buffer buffer; + }; + static_assert( sizeof( MemoryDedicatedAllocateInfoKHR ) == sizeof( VkMemoryDedicatedAllocateInfoKHR ), "struct and wrapper have different size!" ); + + struct TextureLODGatherFormatPropertiesAMD + { + operator const VkTextureLODGatherFormatPropertiesAMD&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PresentInfoKHR const& rhs ) const + bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphores == rhs.pWaitSemaphores ) - && ( swapchainCount == rhs.swapchainCount ) - && ( pSwapchains == rhs.pSwapchains ) - && ( pImageIndices == rhs.pImageIndices ) - && ( pResults == rhs.pResults ); + && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); } - bool operator!=( PresentInfoKHR const& rhs ) const + bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const { return !operator==( rhs ); } @@ -12550,91 +12792,71 @@ namespace vk StructureType sType; public: - const void* pNext; - uint32_t waitSemaphoreCount; - const Semaphore* pWaitSemaphores; - uint32_t swapchainCount; - const SwapchainKHR* pSwapchains; - const uint32_t* pImageIndices; - Result* pResults; - }; - static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); - - enum class DynamicState - { - eViewport = VK_DYNAMIC_STATE_VIEWPORT, - eScissor = VK_DYNAMIC_STATE_SCISSOR, - eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH, - eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS, - eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS, - eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS, - eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, - eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, - eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE, - eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, - eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT + void* pNext; + Bool32 supportsTextureGatherLODBiasAMD; }; + static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); - struct PipelineDynamicStateCreateInfo + struct PipelineCoverageToColorStateCreateInfoNV { - PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr ) - : sType( StructureType::ePipelineDynamicStateCreateInfo ) + PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 ) + : sType( StructureType::ePipelineCoverageToColorStateCreateInfoNV ) , pNext( nullptr ) , flags( flags_ ) - , dynamicStateCount( dynamicStateCount_ ) - , pDynamicStates( pDynamicStates_ ) + , coverageToColorEnable( coverageToColorEnable_ ) + , coverageToColorLocation( coverageToColorLocation_ ) { } - PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) + PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); + memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); } - PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) + PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); + memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); return *this; } - PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ ) + PipelineCoverageToColorStateCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ ) + PipelineCoverageToColorStateCreateInfoNV& setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) { flags = flags_; return *this; } - PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ ) + PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) { - dynamicStateCount = dynamicStateCount_; + coverageToColorEnable = coverageToColorEnable_; return *this; } - PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ ) + PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) { - pDynamicStates = pDynamicStates_; + coverageToColorLocation = coverageToColorLocation_; return *this; } - operator const VkPipelineDynamicStateCreateInfo&() const + operator const VkPipelineCoverageToColorStateCreateInfoNV&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const + bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) - && ( dynamicStateCount == rhs.dynamicStateCount ) - && ( pDynamicStates == rhs.pDynamicStates ); + && ( coverageToColorEnable == rhs.coverageToColorEnable ) + && ( coverageToColorLocation == rhs.coverageToColorLocation ); } - bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const + bool operator!=( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const { return !operator==( rhs ); } @@ -12644,118 +12866,119 @@ namespace vk public: const void* pNext; - PipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const DynamicState* pDynamicStates; + PipelineCoverageToColorStateCreateFlagsNV flags; + Bool32 coverageToColorEnable; + uint32_t coverageToColorLocation; }; - static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); - enum class DescriptorUpdateTemplateTypeKHR + struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { - eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR, - ePushDescriptors = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR + operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) + && ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); + } + + bool operator!=( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + Bool32 filterMinmaxSingleComponentFormats; + Bool32 filterMinmaxImageComponentMapping; }; + static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" ); - struct DescriptorUpdateTemplateCreateInfoKHR + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { - DescriptorUpdateTemplateCreateInfoKHR( DescriptorUpdateTemplateCreateFlagsKHR flags_ = DescriptorUpdateTemplateCreateFlagsKHR(), uint32_t descriptorUpdateEntryCount_ = 0, const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ = nullptr, DescriptorUpdateTemplateTypeKHR templateType_ = DescriptorUpdateTemplateTypeKHR::eDescriptorSet, DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, PipelineLayout pipelineLayout_ = PipelineLayout(), uint32_t set_ = 0 ) - : sType( StructureType::eDescriptorUpdateTemplateCreateInfoKHR ) + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 ) + : sType( StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT ) , pNext( nullptr ) - , flags( flags_ ) - , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) - , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) - , templateType( templateType_ ) - , descriptorSetLayout( descriptorSetLayout_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , pipelineLayout( pipelineLayout_ ) - , set( set_ ) + , advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) { } - DescriptorUpdateTemplateCreateInfoKHR( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); } - DescriptorUpdateTemplateCreateInfoKHR& operator=( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) + PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); return *this; } - DescriptorUpdateTemplateCreateInfoKHR& setPNext( void* pNext_ ) + PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setPNext( void* pNext_ ) { pNext = pNext_; return *this; } - DescriptorUpdateTemplateCreateInfoKHR& setFlags( DescriptorUpdateTemplateCreateFlagsKHR flags_ ) + PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) { - flags = flags_; + advancedBlendCoherentOperations = advancedBlendCoherentOperations_; return *this; } - DescriptorUpdateTemplateCreateInfoKHR& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) + operator const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&() const { - descriptorUpdateEntryCount = descriptorUpdateEntryCount_; - return *this; + return *reinterpret_cast(this); } - DescriptorUpdateTemplateCreateInfoKHR& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ ) + bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const { - pDescriptorUpdateEntries = pDescriptorUpdateEntries_; - return *this; + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); } - DescriptorUpdateTemplateCreateInfoKHR& setTemplateType( DescriptorUpdateTemplateTypeKHR templateType_ ) + bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const { - templateType = templateType_; - return *this; + return !operator==( rhs ); } - DescriptorUpdateTemplateCreateInfoKHR& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) - { - descriptorSetLayout = descriptorSetLayout_; - return *this; - } + private: + StructureType sType; - DescriptorUpdateTemplateCreateInfoKHR& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setPipelineLayout( PipelineLayout pipelineLayout_ ) - { - pipelineLayout = pipelineLayout_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setSet( uint32_t set_ ) - { - set = set_; - return *this; - } + public: + void* pNext; + Bool32 advancedBlendCoherentOperations; + }; + static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); - operator const VkDescriptorUpdateTemplateCreateInfoKHR&() const + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT + { + operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const + bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) - && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) - && ( templateType == rhs.templateType ) - && ( descriptorSetLayout == rhs.descriptorSetLayout ) - && ( pipelineBindPoint == rhs.pipelineBindPoint ) - && ( pipelineLayout == rhs.pipelineLayout ) - && ( set == rhs.set ); + && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) + && ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) + && ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) + && ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) + && ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) + && ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); } - bool operator!=( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const + bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const { return !operator==( rhs ); } @@ -12765,125 +12988,105 @@ namespace vk public: void* pNext; - DescriptorUpdateTemplateCreateFlagsKHR flags; - uint32_t descriptorUpdateEntryCount; - const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries; - DescriptorUpdateTemplateTypeKHR templateType; - DescriptorSetLayout descriptorSetLayout; - PipelineBindPoint pipelineBindPoint; - PipelineLayout pipelineLayout; - uint32_t set; + uint32_t advancedBlendMaxColorAttachments; + Bool32 advancedBlendIndependentBlend; + Bool32 advancedBlendNonPremultipliedSrcColor; + Bool32 advancedBlendNonPremultipliedDstColor; + Bool32 advancedBlendCorrelatedOverlap; + Bool32 advancedBlendAllOperations; }; - static_assert( sizeof( DescriptorUpdateTemplateCreateInfoKHR ) == sizeof( VkDescriptorUpdateTemplateCreateInfoKHR ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); - enum class ObjectType + enum class SubpassContents { - eUnknown = VK_OBJECT_TYPE_UNKNOWN, - eInstance = VK_OBJECT_TYPE_INSTANCE, - ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE, - eDevice = VK_OBJECT_TYPE_DEVICE, - eQueue = VK_OBJECT_TYPE_QUEUE, - eSemaphore = VK_OBJECT_TYPE_SEMAPHORE, - eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER, - eFence = VK_OBJECT_TYPE_FENCE, - eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY, - eBuffer = VK_OBJECT_TYPE_BUFFER, - eImage = VK_OBJECT_TYPE_IMAGE, - eEvent = VK_OBJECT_TYPE_EVENT, - eQueryPool = VK_OBJECT_TYPE_QUERY_POOL, - eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW, - eImageView = VK_OBJECT_TYPE_IMAGE_VIEW, - eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE, - ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE, - ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, - eRenderPass = VK_OBJECT_TYPE_RENDER_PASS, - ePipeline = VK_OBJECT_TYPE_PIPELINE, - eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, - eSampler = VK_OBJECT_TYPE_SAMPLER, - eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, - eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET, - eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, - eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL, - eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR, - eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR, - eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR, - eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, - eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, - eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, - eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX, - eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX + eInline = VK_SUBPASS_CONTENTS_INLINE, + eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS }; - enum class QueueFlagBits + struct PresentInfoKHR { - eGraphics = VK_QUEUE_GRAPHICS_BIT, - eCompute = VK_QUEUE_COMPUTE_BIT, - eTransfer = VK_QUEUE_TRANSFER_BIT, - eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT - }; + PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t swapchainCount_ = 0, const SwapchainKHR* pSwapchains_ = nullptr, const uint32_t* pImageIndices_ = nullptr, Result* pResults_ = nullptr ) + : sType( StructureType::ePresentInfoKHR ) + , pNext( nullptr ) + , waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , swapchainCount( swapchainCount_ ) + , pSwapchains( pSwapchains_ ) + , pImageIndices( pImageIndices_ ) + , pResults( pResults_ ) + { + } - using QueueFlags = Flags; + PresentInfoKHR( VkPresentInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); + } - VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 ) - { - return QueueFlags( bit0 ) | bit1; - } + PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); + return *this; + } + PresentInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } - VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits ) - { - return ~( QueueFlags( bits ) ); - } + PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) + { + waitSemaphoreCount = waitSemaphoreCount_; + return *this; + } - template <> struct FlagTraits - { - enum + PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) { - allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding) - }; - }; + pWaitSemaphores = pWaitSemaphores_; + return *this; + } - struct QueueFamilyProperties - { - operator const VkQueueFamilyProperties&() const + PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ ) { - return *reinterpret_cast(this); + swapchainCount = swapchainCount_; + return *this; } - bool operator==( QueueFamilyProperties const& rhs ) const + PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ ) { - return ( queueFlags == rhs.queueFlags ) - && ( queueCount == rhs.queueCount ) - && ( timestampValidBits == rhs.timestampValidBits ) - && ( minImageTransferGranularity == rhs.minImageTransferGranularity ); + pSwapchains = pSwapchains_; + return *this; } - bool operator!=( QueueFamilyProperties const& rhs ) const + PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ ) { - return !operator==( rhs ); + pImageIndices = pImageIndices_; + return *this; } - QueueFlags queueFlags; - uint32_t queueCount; - uint32_t timestampValidBits; - Extent3D minImageTransferGranularity; - }; - static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" ); + PresentInfoKHR& setPResults( Result* pResults_ ) + { + pResults = pResults_; + return *this; + } - struct QueueFamilyProperties2KHR - { - operator const VkQueueFamilyProperties2KHR&() const + operator const VkPresentInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( QueueFamilyProperties2KHR const& rhs ) const + bool operator==( PresentInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( queueFamilyProperties == rhs.queueFamilyProperties ); + && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) + && ( pWaitSemaphores == rhs.pWaitSemaphores ) + && ( swapchainCount == rhs.swapchainCount ) + && ( pSwapchains == rhs.pSwapchains ) + && ( pImageIndices == rhs.pImageIndices ) + && ( pResults == rhs.pResults ); } - bool operator!=( QueueFamilyProperties2KHR const& rhs ) const + bool operator!=( PresentInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -12892,154 +13095,91 @@ namespace vk StructureType sType; public: - void* pNext; - QueueFamilyProperties queueFamilyProperties; + const void* pNext; + uint32_t waitSemaphoreCount; + const Semaphore* pWaitSemaphores; + uint32_t swapchainCount; + const SwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + Result* pResults; }; - static_assert( sizeof( QueueFamilyProperties2KHR ) == sizeof( VkQueueFamilyProperties2KHR ), "struct and wrapper have different size!" ); + static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); - enum class MemoryPropertyFlagBits + enum class DynamicState { - eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, - eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT, - eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT + eViewport = VK_DYNAMIC_STATE_VIEWPORT, + eScissor = VK_DYNAMIC_STATE_SCISSOR, + eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH, + eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS, + eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS, + eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS, + eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, + eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, + eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, + eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT }; - using MemoryPropertyFlags = Flags; - - VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 ) - { - return MemoryPropertyFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits ) + struct PipelineDynamicStateCreateInfo { - return ~( MemoryPropertyFlags( bits ) ); - } + PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr ) + : sType( StructureType::ePipelineDynamicStateCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) + , dynamicStateCount( dynamicStateCount_ ) + , pDynamicStates( pDynamicStates_ ) + { + } - template <> struct FlagTraits - { - enum + PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) { - allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) - }; - }; - - struct MemoryType - { - operator const VkMemoryType&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryType const& rhs ) const - { - return ( propertyFlags == rhs.propertyFlags ) - && ( heapIndex == rhs.heapIndex ); - } - - bool operator!=( MemoryType const& rhs ) const - { - return !operator==( rhs ); - } - - MemoryPropertyFlags propertyFlags; - uint32_t heapIndex; - }; - static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" ); - - enum class MemoryHeapFlagBits - { - eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, - eMultiInstanceKHX = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX - }; - - using MemoryHeapFlags = Flags; - - VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 ) - { - return MemoryHeapFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits ) - { - return ~( MemoryHeapFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstanceKHX) - }; - }; - - struct MemoryHeap - { - operator const VkMemoryHeap&() const - { - return *reinterpret_cast(this); + memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); } - bool operator==( MemoryHeap const& rhs ) const + PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) { - return ( size == rhs.size ) - && ( flags == rhs.flags ); + memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); + return *this; } - - bool operator!=( MemoryHeap const& rhs ) const + PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ ) { - return !operator==( rhs ); + pNext = pNext_; + return *this; } - DeviceSize size; - MemoryHeapFlags flags; - }; - static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMemoryProperties - { - operator const VkPhysicalDeviceMemoryProperties&() const + PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ ) { - return *reinterpret_cast(this); + flags = flags_; + return *this; } - bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const + PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ ) { - return ( memoryTypeCount == rhs.memoryTypeCount ) - && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 ) - && ( memoryHeapCount == rhs.memoryHeapCount ) - && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 ); + dynamicStateCount = dynamicStateCount_; + return *this; } - bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const + PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ ) { - return !operator==( rhs ); + pDynamicStates = pDynamicStates_; + return *this; } - uint32_t memoryTypeCount; - MemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; - }; - static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMemoryProperties2KHR - { - operator const VkPhysicalDeviceMemoryProperties2KHR&() const + operator const VkPipelineDynamicStateCreateInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceMemoryProperties2KHR const& rhs ) const + bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( memoryProperties == rhs.memoryProperties ); + && ( flags == rhs.flags ) + && ( dynamicStateCount == rhs.dynamicStateCount ) + && ( pDynamicStates == rhs.pDynamicStates ); } - bool operator!=( PhysicalDeviceMemoryProperties2KHR const& rhs ) const + bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const { return !operator==( rhs ); } @@ -13048,213 +13188,247 @@ namespace vk StructureType sType; public: - void* pNext; - PhysicalDeviceMemoryProperties memoryProperties; - }; - static_assert( sizeof( PhysicalDeviceMemoryProperties2KHR ) == sizeof( VkPhysicalDeviceMemoryProperties2KHR ), "struct and wrapper have different size!" ); - - enum class AccessFlagBits - { - eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, - eIndexRead = VK_ACCESS_INDEX_READ_BIT, - eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, - eUniformRead = VK_ACCESS_UNIFORM_READ_BIT, - eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, - eShaderRead = VK_ACCESS_SHADER_READ_BIT, - eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT, - eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, - eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, - eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, - eTransferRead = VK_ACCESS_TRANSFER_READ_BIT, - eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT, - eHostRead = VK_ACCESS_HOST_READ_BIT, - eHostWrite = VK_ACCESS_HOST_WRITE_BIT, - eMemoryRead = VK_ACCESS_MEMORY_READ_BIT, - eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT, - eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX, - eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX, - eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT + const void* pNext; + PipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const DynamicState* pDynamicStates; }; + static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" ); - using AccessFlags = Flags; - - VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 ) - { - return AccessFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits ) - { - return ~( AccessFlags( bits ) ); - } - - template <> struct FlagTraits + enum class DescriptorUpdateTemplateTypeKHR { - enum - { - allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) - }; + eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR, + ePushDescriptors = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR }; - struct MemoryBarrier + struct DescriptorUpdateTemplateCreateInfoKHR { - MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() ) - : sType( StructureType::eMemoryBarrier ) + DescriptorUpdateTemplateCreateInfoKHR( DescriptorUpdateTemplateCreateFlagsKHR flags_ = DescriptorUpdateTemplateCreateFlagsKHR(), uint32_t descriptorUpdateEntryCount_ = 0, const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ = nullptr, DescriptorUpdateTemplateTypeKHR templateType_ = DescriptorUpdateTemplateTypeKHR::eDescriptorSet, DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, PipelineLayout pipelineLayout_ = PipelineLayout(), uint32_t set_ = 0 ) + : sType( StructureType::eDescriptorUpdateTemplateCreateInfoKHR ) , pNext( nullptr ) - , srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) + , flags( flags_ ) + , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) + , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) + , templateType( templateType_ ) + , descriptorSetLayout( descriptorSetLayout_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , pipelineLayout( pipelineLayout_ ) + , set( set_ ) { } - MemoryBarrier( VkMemoryBarrier const & rhs ) + DescriptorUpdateTemplateCreateInfoKHR( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( MemoryBarrier ) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); } - MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) + DescriptorUpdateTemplateCreateInfoKHR& operator=( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( MemoryBarrier ) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); return *this; } - MemoryBarrier& setPNext( const void* pNext_ ) + DescriptorUpdateTemplateCreateInfoKHR& setPNext( void* pNext_ ) { pNext = pNext_; return *this; } - MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) + DescriptorUpdateTemplateCreateInfoKHR& setFlags( DescriptorUpdateTemplateCreateFlagsKHR flags_ ) { - srcAccessMask = srcAccessMask_; + flags = flags_; return *this; } - MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) + DescriptorUpdateTemplateCreateInfoKHR& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) { - dstAccessMask = dstAccessMask_; + descriptorUpdateEntryCount = descriptorUpdateEntryCount_; return *this; } - operator const VkMemoryBarrier&() const + DescriptorUpdateTemplateCreateInfoKHR& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ ) { - return *reinterpret_cast(this); + pDescriptorUpdateEntries = pDescriptorUpdateEntries_; + return *this; } - bool operator==( MemoryBarrier const& rhs ) const + DescriptorUpdateTemplateCreateInfoKHR& setTemplateType( DescriptorUpdateTemplateTypeKHR templateType_ ) { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ); + templateType = templateType_; + return *this; } - bool operator!=( MemoryBarrier const& rhs ) const + DescriptorUpdateTemplateCreateInfoKHR& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) { - return !operator==( rhs ); + descriptorSetLayout = descriptorSetLayout_; + return *this; } - private: - StructureType sType; - - public: - const void* pNext; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - }; - static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); - - struct BufferMemoryBarrier - { - BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize size_ = 0 ) - : sType( StructureType::eBufferMemoryBarrier ) - , pNext( nullptr ) - , srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , buffer( buffer_ ) - , offset( offset_ ) - , size( size_ ) + DescriptorUpdateTemplateCreateInfoKHR& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) { + pipelineBindPoint = pipelineBindPoint_; + return *this; } - BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) + DescriptorUpdateTemplateCreateInfoKHR& setPipelineLayout( PipelineLayout pipelineLayout_ ) { - memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); + pipelineLayout = pipelineLayout_; + return *this; } - BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) + DescriptorUpdateTemplateCreateInfoKHR& setSet( uint32_t set_ ) { - memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); - return *this; - } - BufferMemoryBarrier& setPNext( const void* pNext_ ) - { - pNext = pNext_; + set = set_; return *this; } - BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) + operator const VkDescriptorUpdateTemplateCreateInfoKHR&() const { - srcAccessMask = srcAccessMask_; - return *this; + return *reinterpret_cast(this); } - BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) + bool operator==( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const { - dstAccessMask = dstAccessMask_; - return *this; + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) + && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) + && ( templateType == rhs.templateType ) + && ( descriptorSetLayout == rhs.descriptorSetLayout ) + && ( pipelineBindPoint == rhs.pipelineBindPoint ) + && ( pipelineLayout == rhs.pipelineLayout ) + && ( set == rhs.set ); } - BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) + bool operator!=( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; + return !operator==( rhs ); } - BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) + private: + StructureType sType; + + public: + void* pNext; + DescriptorUpdateTemplateCreateFlagsKHR flags; + uint32_t descriptorUpdateEntryCount; + const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries; + DescriptorUpdateTemplateTypeKHR templateType; + DescriptorSetLayout descriptorSetLayout; + PipelineBindPoint pipelineBindPoint; + PipelineLayout pipelineLayout; + uint32_t set; + }; + static_assert( sizeof( DescriptorUpdateTemplateCreateInfoKHR ) == sizeof( VkDescriptorUpdateTemplateCreateInfoKHR ), "struct and wrapper have different size!" ); + + enum class ObjectType + { + eUnknown = VK_OBJECT_TYPE_UNKNOWN, + eInstance = VK_OBJECT_TYPE_INSTANCE, + ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE, + eDevice = VK_OBJECT_TYPE_DEVICE, + eQueue = VK_OBJECT_TYPE_QUEUE, + eSemaphore = VK_OBJECT_TYPE_SEMAPHORE, + eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER, + eFence = VK_OBJECT_TYPE_FENCE, + eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY, + eBuffer = VK_OBJECT_TYPE_BUFFER, + eImage = VK_OBJECT_TYPE_IMAGE, + eEvent = VK_OBJECT_TYPE_EVENT, + eQueryPool = VK_OBJECT_TYPE_QUERY_POOL, + eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW, + eImageView = VK_OBJECT_TYPE_IMAGE_VIEW, + eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE, + ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE, + ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, + eRenderPass = VK_OBJECT_TYPE_RENDER_PASS, + ePipeline = VK_OBJECT_TYPE_PIPELINE, + eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, + eSampler = VK_OBJECT_TYPE_SAMPLER, + eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, + eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET, + eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, + eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL, + eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR, + eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR, + eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR, + eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, + eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, + eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, + eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX, + eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX + }; + + enum class QueueFlagBits + { + eGraphics = VK_QUEUE_GRAPHICS_BIT, + eCompute = VK_QUEUE_COMPUTE_BIT, + eTransfer = VK_QUEUE_TRANSFER_BIT, + eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT + }; + + using QueueFlags = Flags; + + VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 ) + { + return QueueFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits ) + { + return ~( QueueFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } + allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding) + }; + }; - BufferMemoryBarrier& setBuffer( Buffer buffer_ ) + struct QueueFamilyProperties + { + operator const VkQueueFamilyProperties&() const { - buffer = buffer_; - return *this; + return *reinterpret_cast(this); } - BufferMemoryBarrier& setOffset( DeviceSize offset_ ) + bool operator==( QueueFamilyProperties const& rhs ) const { - offset = offset_; - return *this; + return ( queueFlags == rhs.queueFlags ) + && ( queueCount == rhs.queueCount ) + && ( timestampValidBits == rhs.timestampValidBits ) + && ( minImageTransferGranularity == rhs.minImageTransferGranularity ); } - BufferMemoryBarrier& setSize( DeviceSize size_ ) + bool operator!=( QueueFamilyProperties const& rhs ) const { - size = size_; - return *this; + return !operator==( rhs ); } - operator const VkBufferMemoryBarrier&() const + QueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + Extent3D minImageTransferGranularity; + }; + static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" ); + + struct QueueFamilyProperties2KHR + { + operator const VkQueueFamilyProperties2KHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( BufferMemoryBarrier const& rhs ) const + bool operator==( QueueFamilyProperties2KHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ) - && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) - && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) - && ( buffer == rhs.buffer ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); + && ( queueFamilyProperties == rhs.queueFamilyProperties ); } - bool operator!=( BufferMemoryBarrier const& rhs ) const + bool operator!=( QueueFamilyProperties2KHR const& rhs ) const { return !operator==( rhs ); } @@ -13263,161 +13437,154 @@ namespace vk StructureType sType; public: - const void* pNext; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - Buffer buffer; - DeviceSize offset; - DeviceSize size; + void* pNext; + QueueFamilyProperties queueFamilyProperties; }; - static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); + static_assert( sizeof( QueueFamilyProperties2KHR ) == sizeof( VkQueueFamilyProperties2KHR ), "struct and wrapper have different size!" ); - enum class BufferUsageFlagBits + enum class MemoryPropertyFlagBits { - eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, - eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT, - eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, - eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, - eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, - eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, - eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT + eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, + eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT, + eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT }; - using BufferUsageFlags = Flags; + using MemoryPropertyFlags = Flags; - VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 ) + VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 ) { - return BufferUsageFlags( bit0 ) | bit1; + return MemoryPropertyFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits ) + VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits ) { - return ~( BufferUsageFlags( bits ) ); + return ~( MemoryPropertyFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) + allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) }; }; - enum class BufferCreateFlagBits + struct MemoryType { - eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, - eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, - eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT + operator const VkMemoryType&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryType const& rhs ) const + { + return ( propertyFlags == rhs.propertyFlags ) + && ( heapIndex == rhs.heapIndex ); + } + + bool operator!=( MemoryType const& rhs ) const + { + return !operator==( rhs ); + } + + MemoryPropertyFlags propertyFlags; + uint32_t heapIndex; }; + static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" ); - using BufferCreateFlags = Flags; + enum class MemoryHeapFlagBits + { + eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, + eMultiInstanceKHX = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX + }; - VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 ) + using MemoryHeapFlags = Flags; + + VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 ) { - return BufferCreateFlags( bit0 ) | bit1; + return MemoryHeapFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits ) + VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits ) { - return ~( BufferCreateFlags( bits ) ); + return ~( MemoryHeapFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) + allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstanceKHX) }; }; - struct BufferCreateInfo + struct MemoryHeap { - BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), DeviceSize size_ = 0, BufferUsageFlags usage_ = BufferUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr ) - : sType( StructureType::eBufferCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) - , size( size_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) + operator const VkMemoryHeap&() const { + return *reinterpret_cast(this); } - BufferCreateInfo( VkBufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); - } - - BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); - return *this; - } - BufferCreateInfo& setPNext( const void* pNext_ ) + bool operator==( MemoryHeap const& rhs ) const { - pNext = pNext_; - return *this; + return ( size == rhs.size ) + && ( flags == rhs.flags ); } - BufferCreateInfo& setFlags( BufferCreateFlags flags_ ) + bool operator!=( MemoryHeap const& rhs ) const { - flags = flags_; - return *this; + return !operator==( rhs ); } - BufferCreateInfo& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } + DeviceSize size; + MemoryHeapFlags flags; + }; + static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); - BufferCreateInfo& setUsage( BufferUsageFlags usage_ ) + struct PhysicalDeviceMemoryProperties + { + operator const VkPhysicalDeviceMemoryProperties&() const { - usage = usage_; - return *this; + return *reinterpret_cast(this); } - BufferCreateInfo& setSharingMode( SharingMode sharingMode_ ) + bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const { - sharingMode = sharingMode_; - return *this; + return ( memoryTypeCount == rhs.memoryTypeCount ) + && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 ) + && ( memoryHeapCount == rhs.memoryHeapCount ) + && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 ); } - BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) + bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; + return !operator==( rhs ); } - BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } + uint32_t memoryTypeCount; + MemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; + }; + static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" ); - operator const VkBufferCreateInfo&() const + struct PhysicalDeviceMemoryProperties2KHR + { + operator const VkPhysicalDeviceMemoryProperties2KHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( BufferCreateInfo const& rhs ) const + bool operator==( PhysicalDeviceMemoryProperties2KHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( size == rhs.size ) - && ( usage == rhs.usage ) - && ( sharingMode == rhs.sharingMode ) - && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) - && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); + && ( memoryProperties == rhs.memoryProperties ); } - bool operator!=( BufferCreateInfo const& rhs ) const + bool operator!=( PhysicalDeviceMemoryProperties2KHR const& rhs ) const { return !operator==( rhs ); } @@ -13426,202 +13593,213 @@ namespace vk StructureType sType; public: - const void* pNext; - BufferCreateFlags flags; - DeviceSize size; - BufferUsageFlags usage; - SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; + void* pNext; + PhysicalDeviceMemoryProperties memoryProperties; }; - static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceMemoryProperties2KHR ) == sizeof( VkPhysicalDeviceMemoryProperties2KHR ), "struct and wrapper have different size!" ); - enum class ShaderStageFlagBits + enum class AccessFlagBits { - eVertex = VK_SHADER_STAGE_VERTEX_BIT, - eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, - eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, - eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT, - eFragment = VK_SHADER_STAGE_FRAGMENT_BIT, - eCompute = VK_SHADER_STAGE_COMPUTE_BIT, - eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS, - eAll = VK_SHADER_STAGE_ALL + eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, + eIndexRead = VK_ACCESS_INDEX_READ_BIT, + eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, + eUniformRead = VK_ACCESS_UNIFORM_READ_BIT, + eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, + eShaderRead = VK_ACCESS_SHADER_READ_BIT, + eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT, + eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, + eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, + eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, + eTransferRead = VK_ACCESS_TRANSFER_READ_BIT, + eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT, + eHostRead = VK_ACCESS_HOST_READ_BIT, + eHostWrite = VK_ACCESS_HOST_WRITE_BIT, + eMemoryRead = VK_ACCESS_MEMORY_READ_BIT, + eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT, + eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX, + eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX, + eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT }; - using ShaderStageFlags = Flags; + using AccessFlags = Flags; - VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 ) + VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 ) { - return ShaderStageFlags( bit0 ) | bit1; + return AccessFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits ) + VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits ) { - return ~( ShaderStageFlags( bits ) ); + return ~( AccessFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) + allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) }; }; - struct DescriptorSetLayoutBinding + struct MemoryBarrier { - DescriptorSetLayoutBinding( uint32_t binding_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0, ShaderStageFlags stageFlags_ = ShaderStageFlags(), const Sampler* pImmutableSamplers_ = nullptr ) - : binding( binding_ ) - , descriptorType( descriptorType_ ) - , descriptorCount( descriptorCount_ ) - , stageFlags( stageFlags_ ) - , pImmutableSamplers( pImmutableSamplers_ ) - { - } - - DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) + MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() ) + : sType( StructureType::eMemoryBarrier ) + , pNext( nullptr ) + , srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); } - DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); - return *this; - } - DescriptorSetLayoutBinding& setBinding( uint32_t binding_ ) + MemoryBarrier( VkMemoryBarrier const & rhs ) { - binding = binding_; - return *this; + memcpy( this, &rhs, sizeof( MemoryBarrier ) ); } - DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ ) + MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) { - descriptorType = descriptorType_; + memcpy( this, &rhs, sizeof( MemoryBarrier ) ); return *this; } - - DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ ) + MemoryBarrier& setPNext( const void* pNext_ ) { - descriptorCount = descriptorCount_; + pNext = pNext_; return *this; } - DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ ) + MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) { - stageFlags = stageFlags_; + srcAccessMask = srcAccessMask_; return *this; } - DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ ) + MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) { - pImmutableSamplers = pImmutableSamplers_; + dstAccessMask = dstAccessMask_; return *this; } - operator const VkDescriptorSetLayoutBinding&() const + operator const VkMemoryBarrier&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( DescriptorSetLayoutBinding const& rhs ) const + bool operator==( MemoryBarrier const& rhs ) const { - return ( binding == rhs.binding ) - && ( descriptorType == rhs.descriptorType ) - && ( descriptorCount == rhs.descriptorCount ) - && ( stageFlags == rhs.stageFlags ) - && ( pImmutableSamplers == rhs.pImmutableSamplers ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcAccessMask == rhs.srcAccessMask ) + && ( dstAccessMask == rhs.dstAccessMask ); } - bool operator!=( DescriptorSetLayoutBinding const& rhs ) const + bool operator!=( MemoryBarrier const& rhs ) const { return !operator==( rhs ); } - uint32_t binding; - DescriptorType descriptorType; - uint32_t descriptorCount; - ShaderStageFlags stageFlags; - const Sampler* pImmutableSamplers; + private: + StructureType sType; + + public: + const void* pNext; + AccessFlags srcAccessMask; + AccessFlags dstAccessMask; }; - static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" ); + static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); - struct PipelineShaderStageCreateInfo + struct BufferMemoryBarrier { - PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, ShaderModule module_ = ShaderModule(), const char* pName_ = nullptr, const SpecializationInfo* pSpecializationInfo_ = nullptr ) - : sType( StructureType::ePipelineShaderStageCreateInfo ) + BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize size_ = 0 ) + : sType( StructureType::eBufferMemoryBarrier ) , pNext( nullptr ) - , flags( flags_ ) - , stage( stage_ ) - , module( module_ ) - , pName( pName_ ) - , pSpecializationInfo( pSpecializationInfo_ ) + , srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) + , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) + , buffer( buffer_ ) + , offset( offset_ ) + , size( size_ ) { } - PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) + BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); + memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); } - PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) + BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); + memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); return *this; } - PipelineShaderStageCreateInfo& setPNext( const void* pNext_ ) + BufferMemoryBarrier& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ ) + BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) { - flags = flags_; + srcAccessMask = srcAccessMask_; return *this; } - PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ ) + BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) { - stage = stage_; + dstAccessMask = dstAccessMask_; return *this; } - PipelineShaderStageCreateInfo& setModule( ShaderModule module_ ) + BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) { - module = module_; + srcQueueFamilyIndex = srcQueueFamilyIndex_; return *this; } - PipelineShaderStageCreateInfo& setPName( const char* pName_ ) + BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) { - pName = pName_; + dstQueueFamilyIndex = dstQueueFamilyIndex_; return *this; } - PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ ) + BufferMemoryBarrier& setBuffer( Buffer buffer_ ) { - pSpecializationInfo = pSpecializationInfo_; + buffer = buffer_; return *this; } - operator const VkPipelineShaderStageCreateInfo&() const + BufferMemoryBarrier& setOffset( DeviceSize offset_ ) { - return *reinterpret_cast(this); + offset = offset_; + return *this; } - bool operator==( PipelineShaderStageCreateInfo const& rhs ) const + BufferMemoryBarrier& setSize( DeviceSize size_ ) + { + size = size_; + return *this; + } + + operator const VkBufferMemoryBarrier&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BufferMemoryBarrier const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( stage == rhs.stage ) - && ( module == rhs.module ) - && ( pName == rhs.pName ) - && ( pSpecializationInfo == rhs.pSpecializationInfo ); + && ( srcAccessMask == rhs.srcAccessMask ) + && ( dstAccessMask == rhs.dstAccessMask ) + && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) + && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) + && ( buffer == rhs.buffer ) + && ( offset == rhs.offset ) + && ( size == rhs.size ); } - bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const + bool operator!=( BufferMemoryBarrier const& rhs ) const { return !operator==( rhs ); } @@ -13631,150 +13809,160 @@ namespace vk public: const void* pNext; - PipelineShaderStageCreateFlags flags; - ShaderStageFlagBits stage; - ShaderModule module; - const char* pName; - const SpecializationInfo* pSpecializationInfo; + AccessFlags srcAccessMask; + AccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + Buffer buffer; + DeviceSize offset; + DeviceSize size; }; - static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); - struct PushConstantRange + enum class BufferUsageFlagBits { - PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(), uint32_t offset_ = 0, uint32_t size_ = 0 ) - : stageFlags( stageFlags_ ) - , offset( offset_ ) - , size( size_ ) - { - } + eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT, + eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, + eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, + eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, + eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, + eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT + }; - PushConstantRange( VkPushConstantRange const & rhs ) - { - memcpy( this, &rhs, sizeof( PushConstantRange ) ); - } + using BufferUsageFlags = Flags; - PushConstantRange& operator=( VkPushConstantRange const & rhs ) - { - memcpy( this, &rhs, sizeof( PushConstantRange ) ); - return *this; - } - PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ ) - { - stageFlags = stageFlags_; - return *this; - } + VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 ) + { + return BufferUsageFlags( bit0 ) | bit1; + } - PushConstantRange& setOffset( uint32_t offset_ ) - { - offset = offset_; - return *this; - } + VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits ) + { + return ~( BufferUsageFlags( bits ) ); + } - PushConstantRange& setSize( uint32_t size_ ) + template <> struct FlagTraits + { + enum { - size = size_; - return *this; - } + allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) + }; + }; - operator const VkPushConstantRange&() const - { - return *reinterpret_cast(this); - } + enum class BufferCreateFlagBits + { + eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, + eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, + eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT + }; - bool operator==( PushConstantRange const& rhs ) const - { - return ( stageFlags == rhs.stageFlags ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); - } + using BufferCreateFlags = Flags; - bool operator!=( PushConstantRange const& rhs ) const - { - return !operator==( rhs ); - } + VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 ) + { + return BufferCreateFlags( bit0 ) | bit1; + } - ShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; + VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits ) + { + return ~( BufferCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) + }; }; - static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); - struct PipelineLayoutCreateInfo + struct BufferCreateInfo { - PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const PushConstantRange* pPushConstantRanges_ = nullptr ) - : sType( StructureType::ePipelineLayoutCreateInfo ) + BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), DeviceSize size_ = 0, BufferUsageFlags usage_ = BufferUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr ) + : sType( StructureType::eBufferCreateInfo ) , pNext( nullptr ) , flags( flags_ ) - , setLayoutCount( setLayoutCount_ ) - , pSetLayouts( pSetLayouts_ ) - , pushConstantRangeCount( pushConstantRangeCount_ ) - , pPushConstantRanges( pPushConstantRanges_ ) + , size( size_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) { } - PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) + BufferCreateInfo( VkBufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); + memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); } - PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) + BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); + memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); return *this; } - PipelineLayoutCreateInfo& setPNext( const void* pNext_ ) + BufferCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ ) + BufferCreateInfo& setFlags( BufferCreateFlags flags_ ) { flags = flags_; return *this; } - PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ ) + BufferCreateInfo& setSize( DeviceSize size_ ) { - setLayoutCount = setLayoutCount_; + size = size_; return *this; } - PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ ) + BufferCreateInfo& setUsage( BufferUsageFlags usage_ ) { - pSetLayouts = pSetLayouts_; + usage = usage_; return *this; } - PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) + BufferCreateInfo& setSharingMode( SharingMode sharingMode_ ) { - pushConstantRangeCount = pushConstantRangeCount_; + sharingMode = sharingMode_; return *this; } - PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ ) + BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) { - pPushConstantRanges = pPushConstantRanges_; + queueFamilyIndexCount = queueFamilyIndexCount_; return *this; } - operator const VkPipelineLayoutCreateInfo&() const + BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) { - return *reinterpret_cast(this); + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; } - bool operator==( PipelineLayoutCreateInfo const& rhs ) const + operator const VkBufferCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BufferCreateInfo const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) - && ( setLayoutCount == rhs.setLayoutCount ) - && ( pSetLayouts == rhs.pSetLayouts ) - && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) - && ( pPushConstantRanges == rhs.pPushConstantRanges ); + && ( size == rhs.size ) + && ( usage == rhs.usage ) + && ( sharingMode == rhs.sharingMode ) + && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) + && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); } - bool operator!=( PipelineLayoutCreateInfo const& rhs ) const + bool operator!=( BufferCreateInfo const& rhs ) const { return !operator==( rhs ); } @@ -13784,303 +13972,201 @@ namespace vk public: const void* pNext; - PipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const DescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const PushConstantRange* pPushConstantRanges; + BufferCreateFlags flags; + DeviceSize size; + BufferUsageFlags usage; + SharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; }; - static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" ); - enum class ImageUsageFlagBits + enum class ShaderStageFlagBits { - eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, - eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT, - eSampled = VK_IMAGE_USAGE_SAMPLED_BIT, - eStorage = VK_IMAGE_USAGE_STORAGE_BIT, - eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, - eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, - eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, - eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT + eVertex = VK_SHADER_STAGE_VERTEX_BIT, + eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, + eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, + eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT, + eFragment = VK_SHADER_STAGE_FRAGMENT_BIT, + eCompute = VK_SHADER_STAGE_COMPUTE_BIT, + eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS, + eAll = VK_SHADER_STAGE_ALL }; - using ImageUsageFlags = Flags; + using ShaderStageFlags = Flags; - VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 ) + VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 ) { - return ImageUsageFlags( bit0 ) | bit1; + return ShaderStageFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits ) + VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits ) { - return ~( ImageUsageFlags( bits ) ); + return ~( ShaderStageFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) + allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) }; }; - struct SharedPresentSurfaceCapabilitiesKHR + struct DescriptorSetLayoutBinding { - operator const VkSharedPresentSurfaceCapabilitiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); - } - - bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType; - - public: - void* pNext; - ImageUsageFlags sharedPresentSupportedUsageFlags; - }; - static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); - - enum class ImageCreateFlagBits - { - eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, - eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, - eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, - eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, - eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, - eBindSfrKHX = VK_IMAGE_CREATE_BIND_SFR_BIT_KHX, - e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR - }; - - using ImageCreateFlags = Flags; - - VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 ) - { - return ImageCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits ) - { - return ~( ImageCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eBindSfrKHX) | VkFlags(ImageCreateFlagBits::e2DArrayCompatibleKHR) - }; - }; - - struct PhysicalDeviceImageFormatInfo2KHR - { - PhysicalDeviceImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), ImageCreateFlags flags_ = ImageCreateFlags() ) - : sType( StructureType::ePhysicalDeviceImageFormatInfo2KHR ) - , pNext( nullptr ) - , format( format_ ) - , type( type_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , flags( flags_ ) + DescriptorSetLayoutBinding( uint32_t binding_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0, ShaderStageFlags stageFlags_ = ShaderStageFlags(), const Sampler* pImmutableSamplers_ = nullptr ) + : binding( binding_ ) + , descriptorType( descriptorType_ ) + , descriptorCount( descriptorCount_ ) + , stageFlags( stageFlags_ ) + , pImmutableSamplers( pImmutableSamplers_ ) { } - PhysicalDeviceImageFormatInfo2KHR( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) + DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); } - PhysicalDeviceImageFormatInfo2KHR& operator=( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); - return *this; - } - PhysicalDeviceImageFormatInfo2KHR& setPNext( const void* pNext_ ) + DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) { - pNext = pNext_; + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); return *this; } - - PhysicalDeviceImageFormatInfo2KHR& setFormat( Format format_ ) + DescriptorSetLayoutBinding& setBinding( uint32_t binding_ ) { - format = format_; + binding = binding_; return *this; } - PhysicalDeviceImageFormatInfo2KHR& setType( ImageType type_ ) + DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ ) { - type = type_; + descriptorType = descriptorType_; return *this; } - PhysicalDeviceImageFormatInfo2KHR& setTiling( ImageTiling tiling_ ) + DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ ) { - tiling = tiling_; + descriptorCount = descriptorCount_; return *this; } - PhysicalDeviceImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ ) + DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ ) { - usage = usage_; + stageFlags = stageFlags_; return *this; } - PhysicalDeviceImageFormatInfo2KHR& setFlags( ImageCreateFlags flags_ ) + DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ ) { - flags = flags_; + pImmutableSamplers = pImmutableSamplers_; return *this; } - operator const VkPhysicalDeviceImageFormatInfo2KHR&() const + operator const VkDescriptorSetLayoutBinding&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const + bool operator==( DescriptorSetLayoutBinding const& rhs ) const { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( format == rhs.format ) - && ( type == rhs.type ) - && ( tiling == rhs.tiling ) - && ( usage == rhs.usage ) - && ( flags == rhs.flags ); + return ( binding == rhs.binding ) + && ( descriptorType == rhs.descriptorType ) + && ( descriptorCount == rhs.descriptorCount ) + && ( stageFlags == rhs.stageFlags ) + && ( pImmutableSamplers == rhs.pImmutableSamplers ); } - bool operator!=( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const + bool operator!=( DescriptorSetLayoutBinding const& rhs ) const { return !operator==( rhs ); } - private: - StructureType sType; - - public: - const void* pNext; - Format format; - ImageType type; - ImageTiling tiling; - ImageUsageFlags usage; - ImageCreateFlags flags; - }; - static_assert( sizeof( PhysicalDeviceImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceImageFormatInfo2KHR ), "struct and wrapper have different size!" ); - - enum class PipelineCreateFlagBits - { - eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, - eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, - eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, - eViewIndexFromDeviceIndexKHX = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX, - eDispatchBaseKHX = VK_PIPELINE_CREATE_DISPATCH_BASE_KHX - }; - - using PipelineCreateFlags = Flags; - - VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 ) - { - return PipelineCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits ) - { - return ~( PipelineCreateFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX) | VkFlags(PipelineCreateFlagBits::eDispatchBaseKHX) - }; + uint32_t binding; + DescriptorType descriptorType; + uint32_t descriptorCount; + ShaderStageFlags stageFlags; + const Sampler* pImmutableSamplers; }; + static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" ); - struct ComputePipelineCreateInfo + struct PipelineShaderStageCreateInfo { - ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), PipelineLayout layout_ = PipelineLayout(), Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 ) - : sType( StructureType::eComputePipelineCreateInfo ) + PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, ShaderModule module_ = ShaderModule(), const char* pName_ = nullptr, const SpecializationInfo* pSpecializationInfo_ = nullptr ) + : sType( StructureType::ePipelineShaderStageCreateInfo ) , pNext( nullptr ) , flags( flags_ ) , stage( stage_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) + , module( module_ ) + , pName( pName_ ) + , pSpecializationInfo( pSpecializationInfo_ ) { } - ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) + PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); + memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); } - ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) + PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); + memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); return *this; } - ComputePipelineCreateInfo& setPNext( const void* pNext_ ) + PipelineShaderStageCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) + PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ ) { flags = flags_; return *this; } - ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ ) + PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ ) { stage = stage_; return *this; } - ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ ) + PipelineShaderStageCreateInfo& setModule( ShaderModule module_ ) { - layout = layout_; + module = module_; return *this; } - ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) + PipelineShaderStageCreateInfo& setPName( const char* pName_ ) { - basePipelineHandle = basePipelineHandle_; + pName = pName_; return *this; } - ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) + PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ ) { - basePipelineIndex = basePipelineIndex_; + pSpecializationInfo = pSpecializationInfo_; return *this; } - operator const VkComputePipelineCreateInfo&() const + operator const VkPipelineShaderStageCreateInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ComputePipelineCreateInfo const& rhs ) const + bool operator==( PipelineShaderStageCreateInfo const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) - && ( layout == rhs.layout ) - && ( basePipelineHandle == rhs.basePipelineHandle ) - && ( basePipelineIndex == rhs.basePipelineIndex ); + && ( module == rhs.module ) + && ( pName == rhs.pName ) + && ( pSpecializationInfo == rhs.pSpecializationInfo ); } - bool operator!=( ComputePipelineCreateInfo const& rhs ) const + bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const { return !operator==( rhs ); } @@ -14090,231 +14176,150 @@ namespace vk public: const void* pNext; - PipelineCreateFlags flags; - PipelineShaderStageCreateInfo stage; - PipelineLayout layout; - Pipeline basePipelineHandle; - int32_t basePipelineIndex; + PipelineShaderStageCreateFlags flags; + ShaderStageFlagBits stage; + ShaderModule module; + const char* pName; + const SpecializationInfo* pSpecializationInfo; }; - static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" ); - enum class ColorComponentFlagBits + struct PushConstantRange { - eR = VK_COLOR_COMPONENT_R_BIT, - eG = VK_COLOR_COMPONENT_G_BIT, - eB = VK_COLOR_COMPONENT_B_BIT, - eA = VK_COLOR_COMPONENT_A_BIT - }; + PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(), uint32_t offset_ = 0, uint32_t size_ = 0 ) + : stageFlags( stageFlags_ ) + , offset( offset_ ) + , size( size_ ) + { + } - using ColorComponentFlags = Flags; + PushConstantRange( VkPushConstantRange const & rhs ) + { + memcpy( this, &rhs, sizeof( PushConstantRange ) ); + } - VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 ) - { - return ColorComponentFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits ) - { - return ~( ColorComponentFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA) - }; - }; - - struct PipelineColorBlendAttachmentState - { - PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0, BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, BlendOp colorBlendOp_ = BlendOp::eAdd, BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, BlendOp alphaBlendOp_ = BlendOp::eAdd, ColorComponentFlags colorWriteMask_ = ColorComponentFlags() ) - : blendEnable( blendEnable_ ) - , srcColorBlendFactor( srcColorBlendFactor_ ) - , dstColorBlendFactor( dstColorBlendFactor_ ) - , colorBlendOp( colorBlendOp_ ) - , srcAlphaBlendFactor( srcAlphaBlendFactor_ ) - , dstAlphaBlendFactor( dstAlphaBlendFactor_ ) - , alphaBlendOp( alphaBlendOp_ ) - , colorWriteMask( colorWriteMask_ ) - { - } - - PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); - } - - PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); - return *this; - } - PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ ) - { - blendEnable = blendEnable_; - return *this; - } - - PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) - { - srcColorBlendFactor = srcColorBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) - { - dstColorBlendFactor = dstColorBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ ) - { - colorBlendOp = colorBlendOp_; - return *this; - } - - PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) + PushConstantRange& operator=( VkPushConstantRange const & rhs ) { - srcAlphaBlendFactor = srcAlphaBlendFactor_; + memcpy( this, &rhs, sizeof( PushConstantRange ) ); return *this; } - - PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) + PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ ) { - dstAlphaBlendFactor = dstAlphaBlendFactor_; + stageFlags = stageFlags_; return *this; } - PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ ) + PushConstantRange& setOffset( uint32_t offset_ ) { - alphaBlendOp = alphaBlendOp_; + offset = offset_; return *this; } - PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ ) + PushConstantRange& setSize( uint32_t size_ ) { - colorWriteMask = colorWriteMask_; + size = size_; return *this; } - operator const VkPipelineColorBlendAttachmentState&() const + operator const VkPushConstantRange&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PipelineColorBlendAttachmentState const& rhs ) const + bool operator==( PushConstantRange const& rhs ) const { - return ( blendEnable == rhs.blendEnable ) - && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) - && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) - && ( colorBlendOp == rhs.colorBlendOp ) - && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) - && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) - && ( alphaBlendOp == rhs.alphaBlendOp ) - && ( colorWriteMask == rhs.colorWriteMask ); + return ( stageFlags == rhs.stageFlags ) + && ( offset == rhs.offset ) + && ( size == rhs.size ); } - bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const + bool operator!=( PushConstantRange const& rhs ) const { return !operator==( rhs ); } - Bool32 blendEnable; - BlendFactor srcColorBlendFactor; - BlendFactor dstColorBlendFactor; - BlendOp colorBlendOp; - BlendFactor srcAlphaBlendFactor; - BlendFactor dstAlphaBlendFactor; - BlendOp alphaBlendOp; - ColorComponentFlags colorWriteMask; + ShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; }; - static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" ); + static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); - struct PipelineColorBlendStateCreateInfo + struct PipelineLayoutCreateInfo { - PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(), Bool32 logicOpEnable_ = 0, LogicOp logicOp_ = LogicOp::eClear, uint32_t attachmentCount_ = 0, const PipelineColorBlendAttachmentState* pAttachments_ = nullptr, std::array const& blendConstants_ = { { 0, 0, 0, 0 } } ) - : sType( StructureType::ePipelineColorBlendStateCreateInfo ) + PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const PushConstantRange* pPushConstantRanges_ = nullptr ) + : sType( StructureType::ePipelineLayoutCreateInfo ) , pNext( nullptr ) , flags( flags_ ) - , logicOpEnable( logicOpEnable_ ) - , logicOp( logicOp_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) + , setLayoutCount( setLayoutCount_ ) + , pSetLayouts( pSetLayouts_ ) + , pushConstantRangeCount( pushConstantRangeCount_ ) + , pPushConstantRanges( pPushConstantRanges_ ) { - memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); } - PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) + PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); + memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); } - PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) + PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); + memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); return *this; } - PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ ) + PipelineLayoutCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ ) + PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ ) { flags = flags_; return *this; } - PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ ) - { - logicOpEnable = logicOpEnable_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ ) + PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ ) { - logicOp = logicOp_; + setLayoutCount = setLayoutCount_; return *this; } - PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) + PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ ) { - attachmentCount = attachmentCount_; + pSetLayouts = pSetLayouts_; return *this; } - PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ ) + PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) { - pAttachments = pAttachments_; + pushConstantRangeCount = pushConstantRangeCount_; return *this; } - PipelineColorBlendStateCreateInfo& setBlendConstants( std::array blendConstants_ ) + PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ ) { - memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); + pPushConstantRanges = pPushConstantRanges_; return *this; } - operator const VkPipelineColorBlendStateCreateInfo&() const + operator const VkPipelineLayoutCreateInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const + bool operator==( PipelineLayoutCreateInfo const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) - && ( logicOpEnable == rhs.logicOpEnable ) - && ( logicOp == rhs.logicOp ) - && ( attachmentCount == rhs.attachmentCount ) - && ( pAttachments == rhs.pAttachments ) - && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 ); + && ( setLayoutCount == rhs.setLayoutCount ) + && ( pSetLayouts == rhs.pSetLayouts ) + && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) + && ( pPushConstantRanges == rhs.pPushConstantRanges ); } - bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const + bool operator!=( PipelineLayoutCreateInfo const& rhs ) const { return !operator==( rhs ); } @@ -14324,178 +14329,181 @@ namespace vk public: const void* pNext; - PipelineColorBlendStateCreateFlags flags; - Bool32 logicOpEnable; - LogicOp logicOp; - uint32_t attachmentCount; - const PipelineColorBlendAttachmentState* pAttachments; - float blendConstants[4]; + PipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const DescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const PushConstantRange* pPushConstantRanges; }; - static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" ); - enum class FenceCreateFlagBits + enum class ImageUsageFlagBits { - eSignaled = VK_FENCE_CREATE_SIGNALED_BIT + eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, + eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT, + eSampled = VK_IMAGE_USAGE_SAMPLED_BIT, + eStorage = VK_IMAGE_USAGE_STORAGE_BIT, + eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, + eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, + eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT }; - using FenceCreateFlags = Flags; + using ImageUsageFlags = Flags; - VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 ) + VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 ) { - return FenceCreateFlags( bit0 ) | bit1; + return ImageUsageFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits ) + VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits ) { - return ~( FenceCreateFlags( bits ) ); + return ~( ImageUsageFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(FenceCreateFlagBits::eSignaled) + allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) }; }; - struct FenceCreateInfo + struct SharedPresentSurfaceCapabilitiesKHR { - FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() ) - : sType( StructureType::eFenceCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) - { - } - - FenceCreateInfo( VkFenceCreateInfo const & rhs ) + operator const VkSharedPresentSurfaceCapabilitiesKHR&() const { - memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); + return *reinterpret_cast(this); } - FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); - return *this; - } - FenceCreateInfo& setPNext( const void* pNext_ ) + bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const { - pNext = pNext_; - return *this; + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); } - FenceCreateInfo& setFlags( FenceCreateFlags flags_ ) + bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const { - flags = flags_; - return *this; + return !operator==( rhs ); } - operator const VkFenceCreateInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( FenceCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ); - } - - bool operator!=( FenceCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType; + private: + StructureType sType; public: - const void* pNext; - FenceCreateFlags flags; + void* pNext; + ImageUsageFlags sharedPresentSupportedUsageFlags; }; - static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); - enum class FormatFeatureFlagBits + enum class ImageCreateFlagBits { - eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, - eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, - eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, - eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, - eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, - eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, - eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, - eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, - eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, - eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT, - eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT, - eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, - eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, - eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, - eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, - eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT + eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, + eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, + eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, + eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, + eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, + eBindSfrKHX = VK_IMAGE_CREATE_BIND_SFR_BIT_KHX, + e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR }; - using FormatFeatureFlags = Flags; + using ImageCreateFlags = Flags; - VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 ) + VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 ) { - return FormatFeatureFlags( bit0 ) | bit1; + return ImageCreateFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits ) + VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits ) { - return ~( FormatFeatureFlags( bits ) ); + return ~( ImageCreateFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eTransferSrcKHR) | VkFlags(FormatFeatureFlagBits::eTransferDstKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) + allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eBindSfrKHX) | VkFlags(ImageCreateFlagBits::e2DArrayCompatibleKHR) }; }; - struct FormatProperties + struct PhysicalDeviceImageFormatInfo2KHR { - operator const VkFormatProperties&() const + PhysicalDeviceImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), ImageCreateFlags flags_ = ImageCreateFlags() ) + : sType( StructureType::ePhysicalDeviceImageFormatInfo2KHR ) + , pNext( nullptr ) + , format( format_ ) + , type( type_ ) + , tiling( tiling_ ) + , usage( usage_ ) + , flags( flags_ ) { - return *reinterpret_cast(this); } - bool operator==( FormatProperties const& rhs ) const + PhysicalDeviceImageFormatInfo2KHR( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) { - return ( linearTilingFeatures == rhs.linearTilingFeatures ) - && ( optimalTilingFeatures == rhs.optimalTilingFeatures ) - && ( bufferFeatures == rhs.bufferFeatures ); + memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); } - bool operator!=( FormatProperties const& rhs ) const + PhysicalDeviceImageFormatInfo2KHR& operator=( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) { - return !operator==( rhs ); + memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); + return *this; + } + PhysicalDeviceImageFormatInfo2KHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; } - FormatFeatureFlags linearTilingFeatures; - FormatFeatureFlags optimalTilingFeatures; - FormatFeatureFlags bufferFeatures; - }; - static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); + PhysicalDeviceImageFormatInfo2KHR& setFormat( Format format_ ) + { + format = format_; + return *this; + } - struct FormatProperties2KHR - { - operator const VkFormatProperties2KHR&() const + PhysicalDeviceImageFormatInfo2KHR& setType( ImageType type_ ) { - return *reinterpret_cast(this); + type = type_; + return *this; } - bool operator==( FormatProperties2KHR const& rhs ) const + PhysicalDeviceImageFormatInfo2KHR& setTiling( ImageTiling tiling_ ) + { + tiling = tiling_; + return *this; + } + + PhysicalDeviceImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ ) + { + usage = usage_; + return *this; + } + + PhysicalDeviceImageFormatInfo2KHR& setFlags( ImageCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + operator const VkPhysicalDeviceImageFormatInfo2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( formatProperties == rhs.formatProperties ); + && ( format == rhs.format ) + && ( type == rhs.type ) + && ( tiling == rhs.tiling ) + && ( usage == rhs.usage ) + && ( flags == rhs.flags ); } - bool operator!=( FormatProperties2KHR const& rhs ) const + bool operator!=( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const { return !operator==( rhs ); } @@ -14504,280 +14512,354 @@ namespace vk StructureType sType; public: - void* pNext; - FormatProperties formatProperties; + const void* pNext; + Format format; + ImageType type; + ImageTiling tiling; + ImageUsageFlags usage; + ImageCreateFlags flags; }; - static_assert( sizeof( FormatProperties2KHR ) == sizeof( VkFormatProperties2KHR ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceImageFormatInfo2KHR ), "struct and wrapper have different size!" ); - enum class QueryControlFlagBits + enum class PipelineCreateFlagBits { - ePrecise = VK_QUERY_CONTROL_PRECISE_BIT + eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, + eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, + eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, + eViewIndexFromDeviceIndexKHX = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX, + eDispatchBaseKHX = VK_PIPELINE_CREATE_DISPATCH_BASE_KHX }; - using QueryControlFlags = Flags; + using PipelineCreateFlags = Flags; - VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 ) + VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 ) { - return QueryControlFlags( bit0 ) | bit1; + return PipelineCreateFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits ) + VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits ) { - return ~( QueryControlFlags( bits ) ); + return ~( PipelineCreateFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(QueryControlFlagBits::ePrecise) + allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX) | VkFlags(PipelineCreateFlagBits::eDispatchBaseKHX) }; }; - enum class QueryResultFlagBits - { - e64 = VK_QUERY_RESULT_64_BIT, - eWait = VK_QUERY_RESULT_WAIT_BIT, - eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, - ePartial = VK_QUERY_RESULT_PARTIAL_BIT - }; - - using QueryResultFlags = Flags; - - VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 ) + struct ComputePipelineCreateInfo { - return QueryResultFlags( bit0 ) | bit1; - } + ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), PipelineLayout layout_ = PipelineLayout(), Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 ) + : sType( StructureType::eComputePipelineCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) + , stage( stage_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + { + } - VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits ) - { - return ~( QueryResultFlags( bits ) ); - } + ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); + } - template <> struct FlagTraits - { - enum + ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) { - allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial) - }; - }; + memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); + return *this; + } + ComputePipelineCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } - enum class CommandBufferUsageFlagBits - { - eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, - eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, - eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT - }; + ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) + { + flags = flags_; + return *this; + } - using CommandBufferUsageFlags = Flags; + ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ ) + { + stage = stage_; + return *this; + } - VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 ) - { - return CommandBufferUsageFlags( bit0 ) | bit1; - } + ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ ) + { + layout = layout_; + return *this; + } - VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits ) - { - return ~( CommandBufferUsageFlags( bits ) ); - } + ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) + { + basePipelineHandle = basePipelineHandle_; + return *this; + } - template <> struct FlagTraits - { - enum + ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) { - allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse) - }; + basePipelineIndex = basePipelineIndex_; + return *this; + } + + operator const VkComputePipelineCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ComputePipelineCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( stage == rhs.stage ) + && ( layout == rhs.layout ) + && ( basePipelineHandle == rhs.basePipelineHandle ) + && ( basePipelineIndex == rhs.basePipelineIndex ); + } + + bool operator!=( ComputePipelineCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + PipelineCreateFlags flags; + PipelineShaderStageCreateInfo stage; + PipelineLayout layout; + Pipeline basePipelineHandle; + int32_t basePipelineIndex; }; + static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" ); - enum class QueryPipelineStatisticFlagBits + enum class ColorComponentFlagBits { - eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, - eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, - eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, - eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, - eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, - eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, - eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, - eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, - eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, - eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, - eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT + eR = VK_COLOR_COMPONENT_R_BIT, + eG = VK_COLOR_COMPONENT_G_BIT, + eB = VK_COLOR_COMPONENT_B_BIT, + eA = VK_COLOR_COMPONENT_A_BIT }; - using QueryPipelineStatisticFlags = Flags; + using ColorComponentFlags = Flags; - VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 ) + VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 ) { - return QueryPipelineStatisticFlags( bit0 ) | bit1; + return ColorComponentFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits ) + VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits ) { - return ~( QueryPipelineStatisticFlags( bits ) ); + return ~( ColorComponentFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations) + allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA) }; }; - struct CommandBufferInheritanceInfo + struct PipelineColorBlendAttachmentState { - CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Framebuffer framebuffer_ = Framebuffer(), Bool32 occlusionQueryEnable_ = 0, QueryControlFlags queryFlags_ = QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) - : sType( StructureType::eCommandBufferInheritanceInfo ) - , pNext( nullptr ) - , renderPass( renderPass_ ) - , subpass( subpass_ ) - , framebuffer( framebuffer_ ) - , occlusionQueryEnable( occlusionQueryEnable_ ) - , queryFlags( queryFlags_ ) - , pipelineStatistics( pipelineStatistics_ ) + PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0, BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, BlendOp colorBlendOp_ = BlendOp::eAdd, BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, BlendOp alphaBlendOp_ = BlendOp::eAdd, ColorComponentFlags colorWriteMask_ = ColorComponentFlags() ) + : blendEnable( blendEnable_ ) + , srcColorBlendFactor( srcColorBlendFactor_ ) + , dstColorBlendFactor( dstColorBlendFactor_ ) + , colorBlendOp( colorBlendOp_ ) + , srcAlphaBlendFactor( srcAlphaBlendFactor_ ) + , dstAlphaBlendFactor( dstAlphaBlendFactor_ ) + , alphaBlendOp( alphaBlendOp_ ) + , colorWriteMask( colorWriteMask_ ) { } - CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) + PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) { - memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); } - CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) + PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) { - memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); return *this; } - CommandBufferInheritanceInfo& setPNext( const void* pNext_ ) + PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ ) { - pNext = pNext_; + blendEnable = blendEnable_; return *this; } - CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ ) + PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) { - renderPass = renderPass_; + srcColorBlendFactor = srcColorBlendFactor_; return *this; } - CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ ) + PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) { - subpass = subpass_; + dstColorBlendFactor = dstColorBlendFactor_; return *this; } - CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ ) + PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ ) { - framebuffer = framebuffer_; + colorBlendOp = colorBlendOp_; return *this; } - CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) + PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) { - occlusionQueryEnable = occlusionQueryEnable_; + srcAlphaBlendFactor = srcAlphaBlendFactor_; return *this; } - CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ ) + PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) { - queryFlags = queryFlags_; + dstAlphaBlendFactor = dstAlphaBlendFactor_; return *this; } - CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) + PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ ) { - pipelineStatistics = pipelineStatistics_; + alphaBlendOp = alphaBlendOp_; return *this; } - operator const VkCommandBufferInheritanceInfo&() const + PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ ) { - return *reinterpret_cast(this); + colorWriteMask = colorWriteMask_; + return *this; } - bool operator==( CommandBufferInheritanceInfo const& rhs ) const + operator const VkPipelineColorBlendAttachmentState&() const { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( renderPass == rhs.renderPass ) - && ( subpass == rhs.subpass ) - && ( framebuffer == rhs.framebuffer ) - && ( occlusionQueryEnable == rhs.occlusionQueryEnable ) - && ( queryFlags == rhs.queryFlags ) - && ( pipelineStatistics == rhs.pipelineStatistics ); + return *reinterpret_cast(this); } - bool operator!=( CommandBufferInheritanceInfo const& rhs ) const + bool operator==( PipelineColorBlendAttachmentState const& rhs ) const { - return !operator==( rhs ); + return ( blendEnable == rhs.blendEnable ) + && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) + && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) + && ( colorBlendOp == rhs.colorBlendOp ) + && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) + && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) + && ( alphaBlendOp == rhs.alphaBlendOp ) + && ( colorWriteMask == rhs.colorWriteMask ); } - private: - StructureType sType; + bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const + { + return !operator==( rhs ); + } - public: - const void* pNext; - RenderPass renderPass; - uint32_t subpass; - Framebuffer framebuffer; - Bool32 occlusionQueryEnable; - QueryControlFlags queryFlags; - QueryPipelineStatisticFlags pipelineStatistics; + Bool32 blendEnable; + BlendFactor srcColorBlendFactor; + BlendFactor dstColorBlendFactor; + BlendOp colorBlendOp; + BlendFactor srcAlphaBlendFactor; + BlendFactor dstAlphaBlendFactor; + BlendOp alphaBlendOp; + ColorComponentFlags colorWriteMask; }; - static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" ); - struct CommandBufferBeginInfo + struct PipelineColorBlendStateCreateInfo { - CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) - : sType( StructureType::eCommandBufferBeginInfo ) + PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(), Bool32 logicOpEnable_ = 0, LogicOp logicOp_ = LogicOp::eClear, uint32_t attachmentCount_ = 0, const PipelineColorBlendAttachmentState* pAttachments_ = nullptr, std::array const& blendConstants_ = { { 0, 0, 0, 0 } } ) + : sType( StructureType::ePipelineColorBlendStateCreateInfo ) , pNext( nullptr ) , flags( flags_ ) - , pInheritanceInfo( pInheritanceInfo_ ) + , logicOpEnable( logicOpEnable_ ) + , logicOp( logicOp_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) { + memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); } - CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) + PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); } - CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) + PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); return *this; } - CommandBufferBeginInfo& setPNext( const void* pNext_ ) + PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ ) + PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ ) { flags = flags_; return *this; } - CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ ) + PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ ) { - pInheritanceInfo = pInheritanceInfo_; + logicOpEnable = logicOpEnable_; return *this; } - operator const VkCommandBufferBeginInfo&() const + PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ ) { - return *reinterpret_cast(this); + logicOp = logicOp_; + return *this; } - bool operator==( CommandBufferBeginInfo const& rhs ) const + PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) + { + attachmentCount = attachmentCount_; + return *this; + } + + PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ ) + { + pAttachments = pAttachments_; + return *this; + } + + PipelineColorBlendStateCreateInfo& setBlendConstants( std::array blendConstants_ ) + { + memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); + return *this; + } + + operator const VkPipelineColorBlendStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) - && ( pInheritanceInfo == rhs.pInheritanceInfo ); + && ( logicOpEnable == rhs.logicOpEnable ) + && ( logicOp == rhs.logicOp ) + && ( attachmentCount == rhs.attachmentCount ) + && ( pAttachments == rhs.pAttachments ) + && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 ); } - bool operator!=( CommandBufferBeginInfo const& rhs ) const + bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const { return !operator==( rhs ); } @@ -14787,79 +14869,84 @@ namespace vk public: const void* pNext; - CommandBufferUsageFlags flags; - const CommandBufferInheritanceInfo* pInheritanceInfo; + PipelineColorBlendStateCreateFlags flags; + Bool32 logicOpEnable; + LogicOp logicOp; + uint32_t attachmentCount; + const PipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; }; - static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" ); - struct QueryPoolCreateInfo + enum class FenceCreateFlagBits { - QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) - : sType( StructureType::eQueryPoolCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) - , queryType( queryType_ ) - , queryCount( queryCount_ ) - , pipelineStatistics( pipelineStatistics_ ) - { - } + eSignaled = VK_FENCE_CREATE_SIGNALED_BIT + }; - QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); - } + using FenceCreateFlags = Flags; - QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) + VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 ) + { + return FenceCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits ) + { + return ~( FenceCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum { - memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); - return *this; - } - QueryPoolCreateInfo& setPNext( const void* pNext_ ) + allFlags = VkFlags(FenceCreateFlagBits::eSignaled) + }; + }; + + struct FenceCreateInfo + { + FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() ) + : sType( StructureType::eFenceCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) { - pNext = pNext_; - return *this; } - QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ ) + FenceCreateInfo( VkFenceCreateInfo const & rhs ) { - flags = flags_; - return *this; + memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); } - QueryPoolCreateInfo& setQueryType( QueryType queryType_ ) + FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) { - queryType = queryType_; + memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); return *this; } - - QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ ) + FenceCreateInfo& setPNext( const void* pNext_ ) { - queryCount = queryCount_; + pNext = pNext_; return *this; } - QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) + FenceCreateInfo& setFlags( FenceCreateFlags flags_ ) { - pipelineStatistics = pipelineStatistics_; + flags = flags_; return *this; } - operator const VkQueryPoolCreateInfo&() const + operator const VkFenceCreateInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( QueryPoolCreateInfo const& rhs ) const + bool operator==( FenceCreateInfo const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queryType == rhs.queryType ) - && ( queryCount == rhs.queryCount ) - && ( pipelineStatistics == rhs.pipelineStatistics ); + && ( flags == rhs.flags ); } - bool operator!=( QueryPoolCreateInfo const& rhs ) const + bool operator!=( FenceCreateInfo const& rhs ) const { return !operator==( rhs ); } @@ -14869,348 +14956,303 @@ namespace vk public: const void* pNext; - QueryPoolCreateFlags flags; - QueryType queryType; - uint32_t queryCount; - QueryPipelineStatisticFlags pipelineStatistics; + FenceCreateFlags flags; }; - static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); - enum class ImageAspectFlagBits + enum class FormatFeatureFlagBits { - eColor = VK_IMAGE_ASPECT_COLOR_BIT, - eDepth = VK_IMAGE_ASPECT_DEPTH_BIT, - eStencil = VK_IMAGE_ASPECT_STENCIL_BIT, - eMetadata = VK_IMAGE_ASPECT_METADATA_BIT + eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, + eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, + eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, + eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, + eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, + eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, + eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, + eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, + eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, + eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, + eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT, + eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT, + eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, + eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, + eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, + eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, + eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT }; - using ImageAspectFlags = Flags; + using FormatFeatureFlags = Flags; - VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 ) + VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 ) { - return ImageAspectFlags( bit0 ) | bit1; + return FormatFeatureFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits ) + VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits ) { - return ~( ImageAspectFlags( bits ) ); + return ~( FormatFeatureFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) + allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eTransferSrcKHR) | VkFlags(FormatFeatureFlagBits::eTransferDstKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) }; }; - struct ImageSubresource + struct FormatProperties { - ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t arrayLayer_ = 0 ) - : aspectMask( aspectMask_ ) - , mipLevel( mipLevel_ ) - , arrayLayer( arrayLayer_ ) - { - } - - ImageSubresource( VkImageSubresource const & rhs ) + operator const VkFormatProperties&() const { - memcpy( this, &rhs, sizeof( ImageSubresource ) ); + return *reinterpret_cast(this); } - ImageSubresource& operator=( VkImageSubresource const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresource ) ); - return *this; - } - ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ ) + bool operator==( FormatProperties const& rhs ) const { - aspectMask = aspectMask_; - return *this; + return ( linearTilingFeatures == rhs.linearTilingFeatures ) + && ( optimalTilingFeatures == rhs.optimalTilingFeatures ) + && ( bufferFeatures == rhs.bufferFeatures ); } - ImageSubresource& setMipLevel( uint32_t mipLevel_ ) + bool operator!=( FormatProperties const& rhs ) const { - mipLevel = mipLevel_; - return *this; + return !operator==( rhs ); } - ImageSubresource& setArrayLayer( uint32_t arrayLayer_ ) - { - arrayLayer = arrayLayer_; - return *this; - } + FormatFeatureFlags linearTilingFeatures; + FormatFeatureFlags optimalTilingFeatures; + FormatFeatureFlags bufferFeatures; + }; + static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); - operator const VkImageSubresource&() const + struct FormatProperties2KHR + { + operator const VkFormatProperties2KHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImageSubresource const& rhs ) const + bool operator==( FormatProperties2KHR const& rhs ) const { - return ( aspectMask == rhs.aspectMask ) - && ( mipLevel == rhs.mipLevel ) - && ( arrayLayer == rhs.arrayLayer ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( formatProperties == rhs.formatProperties ); } - bool operator!=( ImageSubresource const& rhs ) const + bool operator!=( FormatProperties2KHR const& rhs ) const { return !operator==( rhs ); } - ImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t arrayLayer; + private: + StructureType sType; + + public: + void* pNext; + FormatProperties formatProperties; }; - static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" ); + static_assert( sizeof( FormatProperties2KHR ) == sizeof( VkFormatProperties2KHR ), "struct and wrapper have different size!" ); - struct ImageSubresourceLayers + enum class QueryControlFlagBits { - ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 ) - : aspectMask( aspectMask_ ) - , mipLevel( mipLevel_ ) - , baseArrayLayer( baseArrayLayer_ ) - , layerCount( layerCount_ ) - { - } + ePrecise = VK_QUERY_CONTROL_PRECISE_BIT + }; - ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); - } + using QueryControlFlags = Flags; - ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); - return *this; - } - ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } + VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 ) + { + return QueryControlFlags( bit0 ) | bit1; + } - ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ ) - { - mipLevel = mipLevel_; - return *this; - } + VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits ) + { + return ~( QueryControlFlags( bits ) ); + } - ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ ) + template <> struct FlagTraits + { + enum { - baseArrayLayer = baseArrayLayer_; - return *this; - } + allFlags = VkFlags(QueryControlFlagBits::ePrecise) + }; + }; - ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ ) - { - layerCount = layerCount_; - return *this; - } + enum class QueryResultFlagBits + { + e64 = VK_QUERY_RESULT_64_BIT, + eWait = VK_QUERY_RESULT_WAIT_BIT, + eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, + ePartial = VK_QUERY_RESULT_PARTIAL_BIT + }; - operator const VkImageSubresourceLayers&() const - { - return *reinterpret_cast(this); - } + using QueryResultFlags = Flags; - bool operator==( ImageSubresourceLayers const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( mipLevel == rhs.mipLevel ) - && ( baseArrayLayer == rhs.baseArrayLayer ) - && ( layerCount == rhs.layerCount ); - } + VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 ) + { + return QueryResultFlags( bit0 ) | bit1; + } - bool operator!=( ImageSubresourceLayers const& rhs ) const - { - return !operator==( rhs ); - } + VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits ) + { + return ~( QueryResultFlags( bits ) ); + } - ImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t baseArrayLayer; - uint32_t layerCount; + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial) + }; }; - static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" ); - struct ImageSubresourceRange + enum class CommandBufferUsageFlagBits { - ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t baseMipLevel_ = 0, uint32_t levelCount_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 ) - : aspectMask( aspectMask_ ) - , baseMipLevel( baseMipLevel_ ) - , levelCount( levelCount_ ) - , baseArrayLayer( baseArrayLayer_ ) - , layerCount( layerCount_ ) - { - } + eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, + eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, + eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT + }; - ImageSubresourceRange( VkImageSubresourceRange const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); - } + using CommandBufferUsageFlags = Flags; - ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); - return *this; - } - ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } + VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 ) + { + return CommandBufferUsageFlags( bit0 ) | bit1; + } - ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ ) - { - baseMipLevel = baseMipLevel_; - return *this; - } + VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits ) + { + return ~( CommandBufferUsageFlags( bits ) ); + } - ImageSubresourceRange& setLevelCount( uint32_t levelCount_ ) + template <> struct FlagTraits + { + enum { - levelCount = levelCount_; - return *this; - } + allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse) + }; + }; - ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ ) - { - baseArrayLayer = baseArrayLayer_; - return *this; - } + enum class QueryPipelineStatisticFlagBits + { + eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, + eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, + eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, + eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, + eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, + eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, + eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, + eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, + eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, + eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, + eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT + }; - ImageSubresourceRange& setLayerCount( uint32_t layerCount_ ) - { - layerCount = layerCount_; - return *this; - } + using QueryPipelineStatisticFlags = Flags; - operator const VkImageSubresourceRange&() const - { - return *reinterpret_cast(this); - } + VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 ) + { + return QueryPipelineStatisticFlags( bit0 ) | bit1; + } - bool operator==( ImageSubresourceRange const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( baseMipLevel == rhs.baseMipLevel ) - && ( levelCount == rhs.levelCount ) - && ( baseArrayLayer == rhs.baseArrayLayer ) - && ( layerCount == rhs.layerCount ); - } + VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits ) + { + return ~( QueryPipelineStatisticFlags( bits ) ); + } - bool operator!=( ImageSubresourceRange const& rhs ) const + template <> struct FlagTraits + { + enum { - return !operator==( rhs ); - } - - ImageAspectFlags aspectMask; - uint32_t baseMipLevel; - uint32_t levelCount; - uint32_t baseArrayLayer; - uint32_t layerCount; + allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations) + }; }; - static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" ); - struct ImageMemoryBarrier + struct CommandBufferInheritanceInfo { - ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), ImageLayout oldLayout_ = ImageLayout::eUndefined, ImageLayout newLayout_ = ImageLayout::eUndefined, uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Image image_ = Image(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) - : sType( StructureType::eImageMemoryBarrier ) + CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Framebuffer framebuffer_ = Framebuffer(), Bool32 occlusionQueryEnable_ = 0, QueryControlFlags queryFlags_ = QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) + : sType( StructureType::eCommandBufferInheritanceInfo ) , pNext( nullptr ) - , srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , oldLayout( oldLayout_ ) - , newLayout( newLayout_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , image( image_ ) - , subresourceRange( subresourceRange_ ) + , renderPass( renderPass_ ) + , subpass( subpass_ ) + , framebuffer( framebuffer_ ) + , occlusionQueryEnable( occlusionQueryEnable_ ) + , queryFlags( queryFlags_ ) + , pipelineStatistics( pipelineStatistics_ ) { } - ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) + CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) { - memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); + memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); } - ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) + CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) { - memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); + memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); return *this; } - ImageMemoryBarrier& setPNext( const void* pNext_ ) + CommandBufferInheritanceInfo& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) - { - srcAccessMask = srcAccessMask_; - return *this; - } - - ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) - { - dstAccessMask = dstAccessMask_; - return *this; - } - - ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ ) + CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ ) { - oldLayout = oldLayout_; + renderPass = renderPass_; return *this; } - ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ ) + CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ ) { - newLayout = newLayout_; + subpass = subpass_; return *this; } - ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) + CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ ) { - srcQueueFamilyIndex = srcQueueFamilyIndex_; + framebuffer = framebuffer_; return *this; } - ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) + CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) { - dstQueueFamilyIndex = dstQueueFamilyIndex_; + occlusionQueryEnable = occlusionQueryEnable_; return *this; } - ImageMemoryBarrier& setImage( Image image_ ) + CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ ) { - image = image_; + queryFlags = queryFlags_; return *this; } - ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) + CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) { - subresourceRange = subresourceRange_; + pipelineStatistics = pipelineStatistics_; return *this; } - operator const VkImageMemoryBarrier&() const + operator const VkCommandBufferInheritanceInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImageMemoryBarrier const& rhs ) const + bool operator==( CommandBufferInheritanceInfo const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ) - && ( oldLayout == rhs.oldLayout ) - && ( newLayout == rhs.newLayout ) - && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) - && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) - && ( image == rhs.image ) - && ( subresourceRange == rhs.subresourceRange ); + && ( renderPass == rhs.renderPass ) + && ( subpass == rhs.subpass ) + && ( framebuffer == rhs.framebuffer ) + && ( occlusionQueryEnable == rhs.occlusionQueryEnable ) + && ( queryFlags == rhs.queryFlags ) + && ( pipelineStatistics == rhs.pipelineStatistics ); } - bool operator!=( ImageMemoryBarrier const& rhs ) const + bool operator!=( CommandBufferInheritanceInfo const& rhs ) const { return !operator==( rhs ); } @@ -15220,101 +15262,67 @@ namespace vk public: const void* pNext; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - ImageLayout oldLayout; - ImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - Image image; - ImageSubresourceRange subresourceRange; + RenderPass renderPass; + uint32_t subpass; + Framebuffer framebuffer; + Bool32 occlusionQueryEnable; + QueryControlFlags queryFlags; + QueryPipelineStatisticFlags pipelineStatistics; }; - static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); + static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" ); - struct ImageViewCreateInfo + struct CommandBufferBeginInfo { - ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), Image image_ = Image(), ImageViewType viewType_ = ImageViewType::e1D, Format format_ = Format::eUndefined, ComponentMapping components_ = ComponentMapping(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) - : sType( StructureType::eImageViewCreateInfo ) + CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) + : sType( StructureType::eCommandBufferBeginInfo ) , pNext( nullptr ) , flags( flags_ ) - , image( image_ ) - , viewType( viewType_ ) - , format( format_ ) - , components( components_ ) - , subresourceRange( subresourceRange_ ) + , pInheritanceInfo( pInheritanceInfo_ ) { } - ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) + CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); + memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); } - ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) + CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); + memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); return *this; } - ImageViewCreateInfo& setPNext( const void* pNext_ ) + CommandBufferBeginInfo& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ ) + CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ ) { flags = flags_; return *this; } - ImageViewCreateInfo& setImage( Image image_ ) - { - image = image_; - return *this; - } - - ImageViewCreateInfo& setViewType( ImageViewType viewType_ ) - { - viewType = viewType_; - return *this; - } - - ImageViewCreateInfo& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - ImageViewCreateInfo& setComponents( ComponentMapping components_ ) - { - components = components_; - return *this; - } - - ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) + CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ ) { - subresourceRange = subresourceRange_; + pInheritanceInfo = pInheritanceInfo_; return *this; } - operator const VkImageViewCreateInfo&() const + operator const VkCommandBufferBeginInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImageViewCreateInfo const& rhs ) const + bool operator==( CommandBufferBeginInfo const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) - && ( image == rhs.image ) - && ( viewType == rhs.viewType ) - && ( format == rhs.format ) - && ( components == rhs.components ) - && ( subresourceRange == rhs.subresourceRange ); + && ( pInheritanceInfo == rhs.pInheritanceInfo ); } - bool operator!=( ImageViewCreateInfo const& rhs ) const + bool operator!=( CommandBufferBeginInfo const& rhs ) const { return !operator==( rhs ); } @@ -15324,471 +15332,430 @@ namespace vk public: const void* pNext; - ImageViewCreateFlags flags; - Image image; - ImageViewType viewType; - Format format; - ComponentMapping components; - ImageSubresourceRange subresourceRange; + CommandBufferUsageFlags flags; + const CommandBufferInheritanceInfo* pInheritanceInfo; }; - static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" ); - struct ImageCopy + struct QueryPoolCreateInfo { - ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() ) - : srcSubresource( srcSubresource_ ) - , srcOffset( srcOffset_ ) - , dstSubresource( dstSubresource_ ) - , dstOffset( dstOffset_ ) - , extent( extent_ ) + QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) + : sType( StructureType::eQueryPoolCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) + , queryType( queryType_ ) + , queryCount( queryCount_ ) + , pipelineStatistics( pipelineStatistics_ ) { } - ImageCopy( VkImageCopy const & rhs ) + QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( ImageCopy ) ); + memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); } - ImageCopy& operator=( VkImageCopy const & rhs ) + QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( ImageCopy ) ); + memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); return *this; } - ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) + QueryPoolCreateInfo& setPNext( const void* pNext_ ) { - srcSubresource = srcSubresource_; + pNext = pNext_; return *this; } - ImageCopy& setSrcOffset( Offset3D srcOffset_ ) + QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ ) { - srcOffset = srcOffset_; + flags = flags_; return *this; } - ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) + QueryPoolCreateInfo& setQueryType( QueryType queryType_ ) { - dstSubresource = dstSubresource_; + queryType = queryType_; return *this; } - ImageCopy& setDstOffset( Offset3D dstOffset_ ) + QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ ) { - dstOffset = dstOffset_; + queryCount = queryCount_; return *this; } - ImageCopy& setExtent( Extent3D extent_ ) + QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) { - extent = extent_; + pipelineStatistics = pipelineStatistics_; return *this; } - operator const VkImageCopy&() const + operator const VkQueryPoolCreateInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImageCopy const& rhs ) const + bool operator==( QueryPoolCreateInfo const& rhs ) const { - return ( srcSubresource == rhs.srcSubresource ) - && ( srcOffset == rhs.srcOffset ) - && ( dstSubresource == rhs.dstSubresource ) - && ( dstOffset == rhs.dstOffset ) - && ( extent == rhs.extent ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( queryType == rhs.queryType ) + && ( queryCount == rhs.queryCount ) + && ( pipelineStatistics == rhs.pipelineStatistics ); } - bool operator!=( ImageCopy const& rhs ) const + bool operator!=( QueryPoolCreateInfo const& rhs ) const { return !operator==( rhs ); } - ImageSubresourceLayers srcSubresource; - Offset3D srcOffset; - ImageSubresourceLayers dstSubresource; - Offset3D dstOffset; - Extent3D extent; + private: + StructureType sType; + + public: + const void* pNext; + QueryPoolCreateFlags flags; + QueryType queryType; + uint32_t queryCount; + QueryPipelineStatisticFlags pipelineStatistics; }; - static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); + static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); - struct ImageBlit + enum class ImageAspectFlagBits { - ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), std::array const& srcOffsets_ = { { Offset3D(), Offset3D() } }, ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), std::array const& dstOffsets_ = { { Offset3D(), Offset3D() } } ) - : srcSubresource( srcSubresource_ ) - , dstSubresource( dstSubresource_ ) + eColor = VK_IMAGE_ASPECT_COLOR_BIT, + eDepth = VK_IMAGE_ASPECT_DEPTH_BIT, + eStencil = VK_IMAGE_ASPECT_STENCIL_BIT, + eMetadata = VK_IMAGE_ASPECT_METADATA_BIT + }; + + using ImageAspectFlags = Flags; + + VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 ) + { + return ImageAspectFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits ) + { + return ~( ImageAspectFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum { - memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); - memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); - } + allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) + }; + }; - ImageBlit( VkImageBlit const & rhs ) + struct ImageSubresource + { + ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t arrayLayer_ = 0 ) + : aspectMask( aspectMask_ ) + , mipLevel( mipLevel_ ) + , arrayLayer( arrayLayer_ ) { - memcpy( this, &rhs, sizeof( ImageBlit ) ); } - ImageBlit& operator=( VkImageBlit const & rhs ) + ImageSubresource( VkImageSubresource const & rhs ) { - memcpy( this, &rhs, sizeof( ImageBlit ) ); - return *this; + memcpy( this, &rhs, sizeof( ImageSubresource ) ); } - ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) + + ImageSubresource& operator=( VkImageSubresource const & rhs ) { - srcSubresource = srcSubresource_; + memcpy( this, &rhs, sizeof( ImageSubresource ) ); return *this; } - - ImageBlit& setSrcOffsets( std::array srcOffsets_ ) + ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ ) { - memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); + aspectMask = aspectMask_; return *this; } - ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) + ImageSubresource& setMipLevel( uint32_t mipLevel_ ) { - dstSubresource = dstSubresource_; + mipLevel = mipLevel_; return *this; } - ImageBlit& setDstOffsets( std::array dstOffsets_ ) + ImageSubresource& setArrayLayer( uint32_t arrayLayer_ ) { - memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); + arrayLayer = arrayLayer_; return *this; } - operator const VkImageBlit&() const + operator const VkImageSubresource&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImageBlit const& rhs ) const + bool operator==( ImageSubresource const& rhs ) const { - return ( srcSubresource == rhs.srcSubresource ) - && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 ) - && ( dstSubresource == rhs.dstSubresource ) - && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 ); + return ( aspectMask == rhs.aspectMask ) + && ( mipLevel == rhs.mipLevel ) + && ( arrayLayer == rhs.arrayLayer ); } - bool operator!=( ImageBlit const& rhs ) const + bool operator!=( ImageSubresource const& rhs ) const { return !operator==( rhs ); } - ImageSubresourceLayers srcSubresource; - Offset3D srcOffsets[2]; - ImageSubresourceLayers dstSubresource; - Offset3D dstOffsets[2]; + ImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; }; - static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" ); - struct BufferImageCopy + struct ImageSubresourceLayers { - BufferImageCopy( DeviceSize bufferOffset_ = 0, uint32_t bufferRowLength_ = 0, uint32_t bufferImageHeight_ = 0, ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(), Offset3D imageOffset_ = Offset3D(), Extent3D imageExtent_ = Extent3D() ) - : bufferOffset( bufferOffset_ ) - , bufferRowLength( bufferRowLength_ ) - , bufferImageHeight( bufferImageHeight_ ) - , imageSubresource( imageSubresource_ ) - , imageOffset( imageOffset_ ) - , imageExtent( imageExtent_ ) + ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 ) + : aspectMask( aspectMask_ ) + , mipLevel( mipLevel_ ) + , baseArrayLayer( baseArrayLayer_ ) + , layerCount( layerCount_ ) { } - BufferImageCopy( VkBufferImageCopy const & rhs ) + ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) { - memcpy( this, &rhs, sizeof( BufferImageCopy ) ); + memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); } - BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) + ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) { - memcpy( this, &rhs, sizeof( BufferImageCopy ) ); + memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); return *this; } - BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ ) + ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ ) { - bufferOffset = bufferOffset_; + aspectMask = aspectMask_; return *this; } - BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ ) + ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ ) { - bufferRowLength = bufferRowLength_; + mipLevel = mipLevel_; return *this; } - BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ ) - { - bufferImageHeight = bufferImageHeight_; - return *this; - } - - BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ ) - { - imageSubresource = imageSubresource_; - return *this; - } - - BufferImageCopy& setImageOffset( Offset3D imageOffset_ ) + ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ ) { - imageOffset = imageOffset_; + baseArrayLayer = baseArrayLayer_; return *this; } - BufferImageCopy& setImageExtent( Extent3D imageExtent_ ) + ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ ) { - imageExtent = imageExtent_; + layerCount = layerCount_; return *this; } - operator const VkBufferImageCopy&() const + operator const VkImageSubresourceLayers&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( BufferImageCopy const& rhs ) const + bool operator==( ImageSubresourceLayers const& rhs ) const { - return ( bufferOffset == rhs.bufferOffset ) - && ( bufferRowLength == rhs.bufferRowLength ) - && ( bufferImageHeight == rhs.bufferImageHeight ) - && ( imageSubresource == rhs.imageSubresource ) - && ( imageOffset == rhs.imageOffset ) - && ( imageExtent == rhs.imageExtent ); + return ( aspectMask == rhs.aspectMask ) + && ( mipLevel == rhs.mipLevel ) + && ( baseArrayLayer == rhs.baseArrayLayer ) + && ( layerCount == rhs.layerCount ); } - bool operator!=( BufferImageCopy const& rhs ) const + bool operator!=( ImageSubresourceLayers const& rhs ) const { return !operator==( rhs ); } - DeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - ImageSubresourceLayers imageSubresource; - Offset3D imageOffset; - Extent3D imageExtent; + ImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; }; - static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" ); - struct ImageResolve + struct ImageSubresourceRange { - ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() ) - : srcSubresource( srcSubresource_ ) - , srcOffset( srcOffset_ ) - , dstSubresource( dstSubresource_ ) - , dstOffset( dstOffset_ ) - , extent( extent_ ) + ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t baseMipLevel_ = 0, uint32_t levelCount_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 ) + : aspectMask( aspectMask_ ) + , baseMipLevel( baseMipLevel_ ) + , levelCount( levelCount_ ) + , baseArrayLayer( baseArrayLayer_ ) + , layerCount( layerCount_ ) { } - ImageResolve( VkImageResolve const & rhs ) + ImageSubresourceRange( VkImageSubresourceRange const & rhs ) { - memcpy( this, &rhs, sizeof( ImageResolve ) ); + memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); } - ImageResolve& operator=( VkImageResolve const & rhs ) + ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) { - memcpy( this, &rhs, sizeof( ImageResolve ) ); + memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); return *this; } - ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) + ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ ) { - srcSubresource = srcSubresource_; + aspectMask = aspectMask_; return *this; } - ImageResolve& setSrcOffset( Offset3D srcOffset_ ) + ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ ) { - srcOffset = srcOffset_; + baseMipLevel = baseMipLevel_; return *this; } - ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) + ImageSubresourceRange& setLevelCount( uint32_t levelCount_ ) { - dstSubresource = dstSubresource_; + levelCount = levelCount_; return *this; } - ImageResolve& setDstOffset( Offset3D dstOffset_ ) + ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ ) { - dstOffset = dstOffset_; + baseArrayLayer = baseArrayLayer_; return *this; } - ImageResolve& setExtent( Extent3D extent_ ) + ImageSubresourceRange& setLayerCount( uint32_t layerCount_ ) { - extent = extent_; + layerCount = layerCount_; return *this; } - operator const VkImageResolve&() const + operator const VkImageSubresourceRange&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImageResolve const& rhs ) const + bool operator==( ImageSubresourceRange const& rhs ) const { - return ( srcSubresource == rhs.srcSubresource ) - && ( srcOffset == rhs.srcOffset ) - && ( dstSubresource == rhs.dstSubresource ) - && ( dstOffset == rhs.dstOffset ) - && ( extent == rhs.extent ); + return ( aspectMask == rhs.aspectMask ) + && ( baseMipLevel == rhs.baseMipLevel ) + && ( levelCount == rhs.levelCount ) + && ( baseArrayLayer == rhs.baseArrayLayer ) + && ( layerCount == rhs.layerCount ); } - bool operator!=( ImageResolve const& rhs ) const + bool operator!=( ImageSubresourceRange const& rhs ) const { return !operator==( rhs ); } - ImageSubresourceLayers srcSubresource; - Offset3D srcOffset; - ImageSubresourceLayers dstSubresource; - Offset3D dstOffset; - Extent3D extent; + ImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; }; - static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" ); - struct ClearAttachment + struct ImageMemoryBarrier { - ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t colorAttachment_ = 0, ClearValue clearValue_ = ClearValue() ) - : aspectMask( aspectMask_ ) - , colorAttachment( colorAttachment_ ) - , clearValue( clearValue_ ) + ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), ImageLayout oldLayout_ = ImageLayout::eUndefined, ImageLayout newLayout_ = ImageLayout::eUndefined, uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Image image_ = Image(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) + : sType( StructureType::eImageMemoryBarrier ) + , pNext( nullptr ) + , srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , oldLayout( oldLayout_ ) + , newLayout( newLayout_ ) + , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) + , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) + , image( image_ ) + , subresourceRange( subresourceRange_ ) { } - ClearAttachment( VkClearAttachment const & rhs ) + ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof( ClearAttachment ) ); + memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); } - ClearAttachment& operator=( VkClearAttachment const & rhs ) + ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof( ClearAttachment ) ); + memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); return *this; } - ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ ) + ImageMemoryBarrier& setPNext( const void* pNext_ ) { - aspectMask = aspectMask_; + pNext = pNext_; return *this; } - ClearAttachment& setColorAttachment( uint32_t colorAttachment_ ) + ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) { - colorAttachment = colorAttachment_; + srcAccessMask = srcAccessMask_; return *this; } - ClearAttachment& setClearValue( ClearValue clearValue_ ) + ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) { - clearValue = clearValue_; + dstAccessMask = dstAccessMask_; return *this; } - operator const VkClearAttachment&() const + ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ ) { - return *reinterpret_cast(this); + oldLayout = oldLayout_; + return *this; } - ImageAspectFlags aspectMask; - uint32_t colorAttachment; - ClearValue clearValue; - }; - static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" ); - - enum class SparseImageFormatFlagBits - { - eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, - eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, - eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT - }; - - using SparseImageFormatFlags = Flags; - - VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 ) - { - return SparseImageFormatFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits ) - { - return ~( SparseImageFormatFlags( bits ) ); - } - - template <> struct FlagTraits - { - enum + ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ ) { - allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize) - }; - }; + newLayout = newLayout_; + return *this; + } - struct SparseImageFormatProperties - { - operator const VkSparseImageFormatProperties&() const + ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) { - return *reinterpret_cast(this); + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return *this; } - bool operator==( SparseImageFormatProperties const& rhs ) const + ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) { - return ( aspectMask == rhs.aspectMask ) - && ( imageGranularity == rhs.imageGranularity ) - && ( flags == rhs.flags ); + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return *this; } - bool operator!=( SparseImageFormatProperties const& rhs ) const + ImageMemoryBarrier& setImage( Image image_ ) { - return !operator==( rhs ); + image = image_; + return *this; } - ImageAspectFlags aspectMask; - Extent3D imageGranularity; - SparseImageFormatFlags flags; - }; - static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" ); + ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) + { + subresourceRange = subresourceRange_; + return *this; + } - struct SparseImageMemoryRequirements - { - operator const VkSparseImageMemoryRequirements&() const + operator const VkImageMemoryBarrier&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( SparseImageMemoryRequirements const& rhs ) const + bool operator==( ImageMemoryBarrier const& rhs ) const { - return ( formatProperties == rhs.formatProperties ) - && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) - && ( imageMipTailSize == rhs.imageMipTailSize ) - && ( imageMipTailOffset == rhs.imageMipTailOffset ) - && ( imageMipTailStride == rhs.imageMipTailStride ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcAccessMask == rhs.srcAccessMask ) + && ( dstAccessMask == rhs.dstAccessMask ) + && ( oldLayout == rhs.oldLayout ) + && ( newLayout == rhs.newLayout ) + && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) + && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) + && ( image == rhs.image ) + && ( subresourceRange == rhs.subresourceRange ); } - bool operator!=( SparseImageMemoryRequirements const& rhs ) const - { - return !operator==( rhs ); - } - - SparseImageFormatProperties formatProperties; - uint32_t imageMipTailFirstLod; - DeviceSize imageMipTailSize; - DeviceSize imageMipTailOffset; - DeviceSize imageMipTailStride; - }; - static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" ); - - struct SparseImageFormatProperties2KHR - { - operator const VkSparseImageFormatProperties2KHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseImageFormatProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( properties == rhs.properties ); - } - - bool operator!=( SparseImageFormatProperties2KHR const& rhs ) const + bool operator!=( ImageMemoryBarrier const& rhs ) const { return !operator==( rhs ); } @@ -15797,639 +15764,604 @@ namespace vk StructureType sType; public: - void* pNext; - SparseImageFormatProperties properties; - }; - static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" ); - - enum class SparseMemoryBindFlagBits - { - eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT + const void* pNext; + AccessFlags srcAccessMask; + AccessFlags dstAccessMask; + ImageLayout oldLayout; + ImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + Image image; + ImageSubresourceRange subresourceRange; }; + static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); - using SparseMemoryBindFlags = Flags; - - VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 ) - { - return SparseMemoryBindFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits ) - { - return ~( SparseMemoryBindFlags( bits ) ); - } - - template <> struct FlagTraits + struct ImageViewCreateInfo { - enum + ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), Image image_ = Image(), ImageViewType viewType_ = ImageViewType::e1D, Format format_ = Format::eUndefined, ComponentMapping components_ = ComponentMapping(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) + : sType( StructureType::eImageViewCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) + , image( image_ ) + , viewType( viewType_ ) + , format( format_ ) + , components( components_ ) + , subresourceRange( subresourceRange_ ) { - allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata) - }; - }; + } - struct SparseMemoryBind - { - SparseMemoryBind( DeviceSize resourceOffset_ = 0, DeviceSize size_ = 0, DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) - : resourceOffset( resourceOffset_ ) - , size( size_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - , flags( flags_ ) + ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) { + memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); } - SparseMemoryBind( VkSparseMemoryBind const & rhs ) + ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); + memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); + return *this; + } + ImageViewCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; } - SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) + ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ ) { - memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); + flags = flags_; return *this; } - SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ ) + + ImageViewCreateInfo& setImage( Image image_ ) { - resourceOffset = resourceOffset_; + image = image_; return *this; } - SparseMemoryBind& setSize( DeviceSize size_ ) + ImageViewCreateInfo& setViewType( ImageViewType viewType_ ) { - size = size_; + viewType = viewType_; return *this; } - SparseMemoryBind& setMemory( DeviceMemory memory_ ) + ImageViewCreateInfo& setFormat( Format format_ ) { - memory = memory_; + format = format_; return *this; } - SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) + ImageViewCreateInfo& setComponents( ComponentMapping components_ ) { - memoryOffset = memoryOffset_; + components = components_; return *this; } - SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) + ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) { - flags = flags_; + subresourceRange = subresourceRange_; return *this; } - operator const VkSparseMemoryBind&() const + operator const VkImageViewCreateInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( SparseMemoryBind const& rhs ) const + bool operator==( ImageViewCreateInfo const& rhs ) const { - return ( resourceOffset == rhs.resourceOffset ) - && ( size == rhs.size ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ) - && ( flags == rhs.flags ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( image == rhs.image ) + && ( viewType == rhs.viewType ) + && ( format == rhs.format ) + && ( components == rhs.components ) + && ( subresourceRange == rhs.subresourceRange ); } - bool operator!=( SparseMemoryBind const& rhs ) const + bool operator!=( ImageViewCreateInfo const& rhs ) const { return !operator==( rhs ); } - DeviceSize resourceOffset; - DeviceSize size; - DeviceMemory memory; - DeviceSize memoryOffset; - SparseMemoryBindFlags flags; + private: + StructureType sType; + + public: + const void* pNext; + ImageViewCreateFlags flags; + Image image; + ImageViewType viewType; + Format format; + ComponentMapping components; + ImageSubresourceRange subresourceRange; }; - static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); - struct SparseImageMemoryBind + struct ImageCopy { - SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(), Offset3D offset_ = Offset3D(), Extent3D extent_ = Extent3D(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) - : subresource( subresource_ ) - , offset( offset_ ) + ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() ) + : srcSubresource( srcSubresource_ ) + , srcOffset( srcOffset_ ) + , dstSubresource( dstSubresource_ ) + , dstOffset( dstOffset_ ) , extent( extent_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - , flags( flags_ ) { } - SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) + ImageCopy( VkImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); + memcpy( this, &rhs, sizeof( ImageCopy ) ); } - SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); - return *this; - } - SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ ) + ImageCopy& operator=( VkImageCopy const & rhs ) { - subresource = subresource_; + memcpy( this, &rhs, sizeof( ImageCopy ) ); return *this; } - - SparseImageMemoryBind& setOffset( Offset3D offset_ ) + ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) { - offset = offset_; + srcSubresource = srcSubresource_; return *this; } - SparseImageMemoryBind& setExtent( Extent3D extent_ ) + ImageCopy& setSrcOffset( Offset3D srcOffset_ ) { - extent = extent_; + srcOffset = srcOffset_; return *this; } - SparseImageMemoryBind& setMemory( DeviceMemory memory_ ) + ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) { - memory = memory_; + dstSubresource = dstSubresource_; return *this; } - SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) + ImageCopy& setDstOffset( Offset3D dstOffset_ ) { - memoryOffset = memoryOffset_; + dstOffset = dstOffset_; return *this; } - SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) + ImageCopy& setExtent( Extent3D extent_ ) { - flags = flags_; + extent = extent_; return *this; } - operator const VkSparseImageMemoryBind&() const + operator const VkImageCopy&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( SparseImageMemoryBind const& rhs ) const + bool operator==( ImageCopy const& rhs ) const { - return ( subresource == rhs.subresource ) - && ( offset == rhs.offset ) - && ( extent == rhs.extent ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ) - && ( flags == rhs.flags ); + return ( srcSubresource == rhs.srcSubresource ) + && ( srcOffset == rhs.srcOffset ) + && ( dstSubresource == rhs.dstSubresource ) + && ( dstOffset == rhs.dstOffset ) + && ( extent == rhs.extent ); } - bool operator!=( SparseImageMemoryBind const& rhs ) const + bool operator!=( ImageCopy const& rhs ) const { return !operator==( rhs ); } - ImageSubresource subresource; - Offset3D offset; + ImageSubresourceLayers srcSubresource; + Offset3D srcOffset; + ImageSubresourceLayers dstSubresource; + Offset3D dstOffset; Extent3D extent; - DeviceMemory memory; - DeviceSize memoryOffset; - SparseMemoryBindFlags flags; }; - static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); - struct SparseBufferMemoryBindInfo + struct ImageBlit { - SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr ) - : buffer( buffer_ ) - , bindCount( bindCount_ ) - , pBinds( pBinds_ ) + ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), std::array const& srcOffsets_ = { { Offset3D(), Offset3D() } }, ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), std::array const& dstOffsets_ = { { Offset3D(), Offset3D() } } ) + : srcSubresource( srcSubresource_ ) + , dstSubresource( dstSubresource_ ) { + memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); + memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); } - SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) + ImageBlit( VkImageBlit const & rhs ) { - memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); + memcpy( this, &rhs, sizeof( ImageBlit ) ); } - SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) + ImageBlit& operator=( VkImageBlit const & rhs ) { - memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); + memcpy( this, &rhs, sizeof( ImageBlit ) ); return *this; } - SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ ) + ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) { - buffer = buffer_; + srcSubresource = srcSubresource_; return *this; } - SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ ) + ImageBlit& setSrcOffsets( std::array srcOffsets_ ) { - bindCount = bindCount_; + memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); return *this; } - SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) + ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) { - pBinds = pBinds_; + dstSubresource = dstSubresource_; return *this; } - operator const VkSparseBufferMemoryBindInfo&() const + ImageBlit& setDstOffsets( std::array dstOffsets_ ) { - return *reinterpret_cast(this); + memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); + return *this; } - bool operator==( SparseBufferMemoryBindInfo const& rhs ) const + operator const VkImageBlit&() const { - return ( buffer == rhs.buffer ) - && ( bindCount == rhs.bindCount ) - && ( pBinds == rhs.pBinds ); + return *reinterpret_cast(this); } - bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const + bool operator==( ImageBlit const& rhs ) const + { + return ( srcSubresource == rhs.srcSubresource ) + && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 ) + && ( dstSubresource == rhs.dstSubresource ) + && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 ); + } + + bool operator!=( ImageBlit const& rhs ) const { return !operator==( rhs ); } - Buffer buffer; - uint32_t bindCount; - const SparseMemoryBind* pBinds; + ImageSubresourceLayers srcSubresource; + Offset3D srcOffsets[2]; + ImageSubresourceLayers dstSubresource; + Offset3D dstOffsets[2]; }; - static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" ); - struct SparseImageOpaqueMemoryBindInfo + struct BufferImageCopy { - SparseImageOpaqueMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr ) - : image( image_ ) - , bindCount( bindCount_ ) - , pBinds( pBinds_ ) + BufferImageCopy( DeviceSize bufferOffset_ = 0, uint32_t bufferRowLength_ = 0, uint32_t bufferImageHeight_ = 0, ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(), Offset3D imageOffset_ = Offset3D(), Extent3D imageExtent_ = Extent3D() ) + : bufferOffset( bufferOffset_ ) + , bufferRowLength( bufferRowLength_ ) + , bufferImageHeight( bufferImageHeight_ ) + , imageSubresource( imageSubresource_ ) + , imageOffset( imageOffset_ ) + , imageExtent( imageExtent_ ) { } - SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) + BufferImageCopy( VkBufferImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); + memcpy( this, &rhs, sizeof( BufferImageCopy ) ); } - SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) + BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); + memcpy( this, &rhs, sizeof( BufferImageCopy ) ); return *this; } - SparseImageOpaqueMemoryBindInfo& setImage( Image image_ ) + BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ ) { - image = image_; + bufferOffset = bufferOffset_; return *this; } - SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ ) + BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ ) { - bindCount = bindCount_; + bufferRowLength = bufferRowLength_; return *this; } - SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) + BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ ) { - pBinds = pBinds_; + bufferImageHeight = bufferImageHeight_; return *this; } - operator const VkSparseImageOpaqueMemoryBindInfo&() const - { - return *reinterpret_cast(this); - } - - bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const - { - return ( image == rhs.image ) - && ( bindCount == rhs.bindCount ) - && ( pBinds == rhs.pBinds ); - } - - bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Image image; - uint32_t bindCount; - const SparseMemoryBind* pBinds; - }; - static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" ); - - struct SparseImageMemoryBindInfo - { - SparseImageMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseImageMemoryBind* pBinds_ = nullptr ) - : image( image_ ) - , bindCount( bindCount_ ) - , pBinds( pBinds_ ) - { - } - - SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); - } - - SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); - return *this; - } - SparseImageMemoryBindInfo& setImage( Image image_ ) + BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ ) { - image = image_; + imageSubresource = imageSubresource_; return *this; } - SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ ) + BufferImageCopy& setImageOffset( Offset3D imageOffset_ ) { - bindCount = bindCount_; + imageOffset = imageOffset_; return *this; } - SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ ) + BufferImageCopy& setImageExtent( Extent3D imageExtent_ ) { - pBinds = pBinds_; + imageExtent = imageExtent_; return *this; } - operator const VkSparseImageMemoryBindInfo&() const + operator const VkBufferImageCopy&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( SparseImageMemoryBindInfo const& rhs ) const + bool operator==( BufferImageCopy const& rhs ) const { - return ( image == rhs.image ) - && ( bindCount == rhs.bindCount ) - && ( pBinds == rhs.pBinds ); + return ( bufferOffset == rhs.bufferOffset ) + && ( bufferRowLength == rhs.bufferRowLength ) + && ( bufferImageHeight == rhs.bufferImageHeight ) + && ( imageSubresource == rhs.imageSubresource ) + && ( imageOffset == rhs.imageOffset ) + && ( imageExtent == rhs.imageExtent ); } - bool operator!=( SparseImageMemoryBindInfo const& rhs ) const + bool operator!=( BufferImageCopy const& rhs ) const { return !operator==( rhs ); } - Image image; - uint32_t bindCount; - const SparseImageMemoryBind* pBinds; + DeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + ImageSubresourceLayers imageSubresource; + Offset3D imageOffset; + Extent3D imageExtent; }; - static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); - struct BindSparseInfo + struct ImageResolve { - BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t bufferBindCount_ = 0, const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, uint32_t imageOpaqueBindCount_ = 0, const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, uint32_t imageBindCount_ = 0, const SparseImageMemoryBindInfo* pImageBinds_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr ) - : sType( StructureType::eBindSparseInfo ) - , pNext( nullptr ) - , waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , bufferBindCount( bufferBindCount_ ) - , pBufferBinds( pBufferBinds_ ) - , imageOpaqueBindCount( imageOpaqueBindCount_ ) - , pImageOpaqueBinds( pImageOpaqueBinds_ ) - , imageBindCount( imageBindCount_ ) - , pImageBinds( pImageBinds_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphores( pSignalSemaphores_ ) + ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() ) + : srcSubresource( srcSubresource_ ) + , srcOffset( srcOffset_ ) + , dstSubresource( dstSubresource_ ) + , dstOffset( dstOffset_ ) + , extent( extent_ ) { } - BindSparseInfo( VkBindSparseInfo const & rhs ) + ImageResolve( VkImageResolve const & rhs ) { - memcpy( this, &rhs, sizeof( BindSparseInfo ) ); + memcpy( this, &rhs, sizeof( ImageResolve ) ); } - BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) + ImageResolve& operator=( VkImageResolve const & rhs ) { - memcpy( this, &rhs, sizeof( BindSparseInfo ) ); + memcpy( this, &rhs, sizeof( ImageResolve ) ); return *this; } - BindSparseInfo& setPNext( const void* pNext_ ) + ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) { - pNext = pNext_; + srcSubresource = srcSubresource_; return *this; } - BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) + ImageResolve& setSrcOffset( Offset3D srcOffset_ ) { - waitSemaphoreCount = waitSemaphoreCount_; + srcOffset = srcOffset_; return *this; } - BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) + ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) { - pWaitSemaphores = pWaitSemaphores_; + dstSubresource = dstSubresource_; return *this; } - BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ ) + ImageResolve& setDstOffset( Offset3D dstOffset_ ) { - bufferBindCount = bufferBindCount_; + dstOffset = dstOffset_; return *this; } - BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ ) + ImageResolve& setExtent( Extent3D extent_ ) { - pBufferBinds = pBufferBinds_; + extent = extent_; return *this; } - BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) + operator const VkImageResolve&() const { - imageOpaqueBindCount = imageOpaqueBindCount_; - return *this; + return *reinterpret_cast(this); } - BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ ) + bool operator==( ImageResolve const& rhs ) const { - pImageOpaqueBinds = pImageOpaqueBinds_; - return *this; + return ( srcSubresource == rhs.srcSubresource ) + && ( srcOffset == rhs.srcOffset ) + && ( dstSubresource == rhs.dstSubresource ) + && ( dstOffset == rhs.dstOffset ) + && ( extent == rhs.extent ); } - BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ ) + bool operator!=( ImageResolve const& rhs ) const { - imageBindCount = imageBindCount_; - return *this; + return !operator==( rhs ); } - BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ ) + ImageSubresourceLayers srcSubresource; + Offset3D srcOffset; + ImageSubresourceLayers dstSubresource; + Offset3D dstOffset; + Extent3D extent; + }; + static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); + + struct ClearAttachment + { + ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t colorAttachment_ = 0, ClearValue clearValue_ = ClearValue() ) + : aspectMask( aspectMask_ ) + , colorAttachment( colorAttachment_ ) + , clearValue( clearValue_ ) { - pImageBinds = pImageBinds_; - return *this; } - BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) + ClearAttachment( VkClearAttachment const & rhs ) { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; + memcpy( this, &rhs, sizeof( ClearAttachment ) ); } - BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ ) + ClearAttachment& operator=( VkClearAttachment const & rhs ) { - pSignalSemaphores = pSignalSemaphores_; + memcpy( this, &rhs, sizeof( ClearAttachment ) ); return *this; } - - operator const VkBindSparseInfo&() const + ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ ) { - return *reinterpret_cast(this); + aspectMask = aspectMask_; + return *this; } - bool operator==( BindSparseInfo const& rhs ) const + ClearAttachment& setColorAttachment( uint32_t colorAttachment_ ) { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphores == rhs.pWaitSemaphores ) - && ( bufferBindCount == rhs.bufferBindCount ) - && ( pBufferBinds == rhs.pBufferBinds ) - && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) - && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) - && ( imageBindCount == rhs.imageBindCount ) - && ( pImageBinds == rhs.pImageBinds ) - && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) - && ( pSignalSemaphores == rhs.pSignalSemaphores ); + colorAttachment = colorAttachment_; + return *this; } - bool operator!=( BindSparseInfo const& rhs ) const + ClearAttachment& setClearValue( ClearValue clearValue_ ) { - return !operator==( rhs ); + clearValue = clearValue_; + return *this; } - private: - StructureType sType; + operator const VkClearAttachment&() const + { + return *reinterpret_cast(this); + } - public: - const void* pNext; - uint32_t waitSemaphoreCount; - const Semaphore* pWaitSemaphores; - uint32_t bufferBindCount; - const SparseBufferMemoryBindInfo* pBufferBinds; - uint32_t imageOpaqueBindCount; - const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; - uint32_t imageBindCount; - const SparseImageMemoryBindInfo* pImageBinds; - uint32_t signalSemaphoreCount; - const Semaphore* pSignalSemaphores; + ImageAspectFlags aspectMask; + uint32_t colorAttachment; + ClearValue clearValue; }; - static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" ); - enum class PipelineStageFlagBits + enum class SparseImageFormatFlagBits { - eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, - eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, - eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, - eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, - eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, - eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, - eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, - eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, - eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, - eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, - eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT, - eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - eHost = VK_PIPELINE_STAGE_HOST_BIT, - eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, - eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX + eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, + eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, + eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT }; - using PipelineStageFlags = Flags; + using SparseImageFormatFlags = Flags; - VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 ) + VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 ) { - return PipelineStageFlags( bit0 ) | bit1; + return SparseImageFormatFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits ) + VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits ) { - return ~( PipelineStageFlags( bits ) ); + return ~( SparseImageFormatFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) + allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize) }; }; - enum class CommandPoolCreateFlagBits - { - eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, - eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT - }; - - using CommandPoolCreateFlags = Flags; - - VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 ) + struct SparseImageFormatProperties { - return CommandPoolCreateFlags( bit0 ) | bit1; - } + operator const VkSparseImageFormatProperties&() const + { + return *reinterpret_cast(this); + } - VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits ) - { - return ~( CommandPoolCreateFlags( bits ) ); - } + bool operator==( SparseImageFormatProperties const& rhs ) const + { + return ( aspectMask == rhs.aspectMask ) + && ( imageGranularity == rhs.imageGranularity ) + && ( flags == rhs.flags ); + } - template <> struct FlagTraits - { - enum + bool operator!=( SparseImageFormatProperties const& rhs ) const { - allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) - }; + return !operator==( rhs ); + } + + ImageAspectFlags aspectMask; + Extent3D imageGranularity; + SparseImageFormatFlags flags; }; + static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" ); - struct CommandPoolCreateInfo + struct SparseImageMemoryRequirements { - CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 ) - : sType( StructureType::eCommandPoolCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) + operator const VkSparseImageMemoryRequirements&() const { + return *reinterpret_cast(this); } - CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) + bool operator==( SparseImageMemoryRequirements const& rhs ) const { - memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); + return ( formatProperties == rhs.formatProperties ) + && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) + && ( imageMipTailSize == rhs.imageMipTailSize ) + && ( imageMipTailOffset == rhs.imageMipTailOffset ) + && ( imageMipTailStride == rhs.imageMipTailStride ); } - CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) + bool operator!=( SparseImageMemoryRequirements const& rhs ) const { - memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); - return *this; + return !operator==( rhs ); } - CommandPoolCreateInfo& setPNext( const void* pNext_ ) + + SparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + DeviceSize imageMipTailSize; + DeviceSize imageMipTailOffset; + DeviceSize imageMipTailStride; + }; + static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" ); + + struct SparseImageFormatProperties2KHR + { + operator const VkSparseImageFormatProperties2KHR&() const { - pNext = pNext_; - return *this; + return *reinterpret_cast(this); } - CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ ) + bool operator==( SparseImageFormatProperties2KHR const& rhs ) const { - flags = flags_; - return *this; + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( properties == rhs.properties ); } - CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) + bool operator!=( SparseImageFormatProperties2KHR const& rhs ) const { - queueFamilyIndex = queueFamilyIndex_; - return *this; + return !operator==( rhs ); } - operator const VkCommandPoolCreateInfo&() const + private: + StructureType sType; + + public: + void* pNext; + SparseImageFormatProperties properties; + }; + static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" ); + + struct SparseImageMemoryRequirements2KHR + { + operator const VkSparseImageMemoryRequirements2KHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( CommandPoolCreateInfo const& rhs ) const + bool operator==( SparseImageMemoryRequirements2KHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queueFamilyIndex == rhs.queueFamilyIndex ); + && ( memoryRequirements == rhs.memoryRequirements ); } - bool operator!=( CommandPoolCreateInfo const& rhs ) const + bool operator!=( SparseImageMemoryRequirements2KHR const& rhs ) const { return !operator==( rhs ); } @@ -16438,570 +16370,497 @@ namespace vk StructureType sType; public: - const void* pNext; - CommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; + void* pNext; + SparseImageMemoryRequirements memoryRequirements; }; - static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( SparseImageMemoryRequirements2KHR ) == sizeof( VkSparseImageMemoryRequirements2KHR ), "struct and wrapper have different size!" ); - enum class CommandPoolResetFlagBits + enum class SparseMemoryBindFlagBits { - eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT + eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT }; - using CommandPoolResetFlags = Flags; + using SparseMemoryBindFlags = Flags; - VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 ) + VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 ) { - return CommandPoolResetFlags( bit0 ) | bit1; + return SparseMemoryBindFlags( bit0 ) | bit1; } - VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits ) + VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits ) { - return ~( CommandPoolResetFlags( bits ) ); + return ~( SparseMemoryBindFlags( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources) + allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata) }; }; - enum class CommandBufferResetFlagBits + struct SparseMemoryBind { - eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT - }; + SparseMemoryBind( DeviceSize resourceOffset_ = 0, DeviceSize size_ = 0, DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) + : resourceOffset( resourceOffset_ ) + , size( size_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + , flags( flags_ ) + { + } - using CommandBufferResetFlags = Flags; + SparseMemoryBind( VkSparseMemoryBind const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); + } - VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 ) - { - return CommandBufferResetFlags( bit0 ) | bit1; - } + SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) + { + memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); + return *this; + } + SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ ) + { + resourceOffset = resourceOffset_; + return *this; + } - VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits ) - { - return ~( CommandBufferResetFlags( bits ) ); - } + SparseMemoryBind& setSize( DeviceSize size_ ) + { + size = size_; + return *this; + } - template <> struct FlagTraits - { - enum + SparseMemoryBind& setMemory( DeviceMemory memory_ ) { - allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources) - }; - }; + memory = memory_; + return *this; + } - enum class SampleCountFlagBits - { - e1 = VK_SAMPLE_COUNT_1_BIT, - e2 = VK_SAMPLE_COUNT_2_BIT, - e4 = VK_SAMPLE_COUNT_4_BIT, - e8 = VK_SAMPLE_COUNT_8_BIT, - e16 = VK_SAMPLE_COUNT_16_BIT, - e32 = VK_SAMPLE_COUNT_32_BIT, - e64 = VK_SAMPLE_COUNT_64_BIT - }; - - using SampleCountFlags = Flags; - - VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 ) - { - return SampleCountFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits ) - { - return ~( SampleCountFlags( bits ) ); - } + SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) + { + memoryOffset = memoryOffset_; + return *this; + } - template <> struct FlagTraits - { - enum + SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) { - allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64) - }; - }; + flags = flags_; + return *this; + } - struct ImageFormatProperties - { - operator const VkImageFormatProperties&() const + operator const VkSparseMemoryBind&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImageFormatProperties const& rhs ) const + bool operator==( SparseMemoryBind const& rhs ) const { - return ( maxExtent == rhs.maxExtent ) - && ( maxMipLevels == rhs.maxMipLevels ) - && ( maxArrayLayers == rhs.maxArrayLayers ) - && ( sampleCounts == rhs.sampleCounts ) - && ( maxResourceSize == rhs.maxResourceSize ); + return ( resourceOffset == rhs.resourceOffset ) + && ( size == rhs.size ) + && ( memory == rhs.memory ) + && ( memoryOffset == rhs.memoryOffset ) + && ( flags == rhs.flags ); } - bool operator!=( ImageFormatProperties const& rhs ) const + bool operator!=( SparseMemoryBind const& rhs ) const { return !operator==( rhs ); } - Extent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArrayLayers; - SampleCountFlags sampleCounts; - DeviceSize maxResourceSize; + DeviceSize resourceOffset; + DeviceSize size; + DeviceMemory memory; + DeviceSize memoryOffset; + SparseMemoryBindFlags flags; }; - static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" ); + static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" ); - struct ImageCreateInfo + struct SparseImageMemoryBind { - ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(), ImageType imageType_ = ImageType::e1D, Format format_ = Format::eUndefined, Extent3D extent_ = Extent3D(), uint32_t mipLevels_ = 0, uint32_t arrayLayers_ = 0, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, ImageLayout initialLayout_ = ImageLayout::eUndefined ) - : sType( StructureType::eImageCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) - , imageType( imageType_ ) - , format( format_ ) + SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(), Offset3D offset_ = Offset3D(), Extent3D extent_ = Extent3D(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) + : subresource( subresource_ ) + , offset( offset_ ) , extent( extent_ ) - , mipLevels( mipLevels_ ) - , arrayLayers( arrayLayers_ ) - , samples( samples_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - , initialLayout( initialLayout_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + , flags( flags_ ) { } - ImageCreateInfo( VkImageCreateInfo const & rhs ) + SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); } - ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) + SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); return *this; } - ImageCreateInfo& setPNext( const void* pNext_ ) + SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ ) { - pNext = pNext_; + subresource = subresource_; return *this; } - ImageCreateInfo& setFlags( ImageCreateFlags flags_ ) + SparseImageMemoryBind& setOffset( Offset3D offset_ ) { - flags = flags_; + offset = offset_; return *this; } - ImageCreateInfo& setImageType( ImageType imageType_ ) + SparseImageMemoryBind& setExtent( Extent3D extent_ ) { - imageType = imageType_; + extent = extent_; return *this; } - ImageCreateInfo& setFormat( Format format_ ) + SparseImageMemoryBind& setMemory( DeviceMemory memory_ ) { - format = format_; + memory = memory_; return *this; } - ImageCreateInfo& setExtent( Extent3D extent_ ) + SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) { - extent = extent_; + memoryOffset = memoryOffset_; return *this; } - ImageCreateInfo& setMipLevels( uint32_t mipLevels_ ) + SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) { - mipLevels = mipLevels_; + flags = flags_; return *this; } - ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ ) + operator const VkSparseImageMemoryBind&() const { - arrayLayers = arrayLayers_; - return *this; + return *reinterpret_cast(this); } - ImageCreateInfo& setSamples( SampleCountFlagBits samples_ ) + bool operator==( SparseImageMemoryBind const& rhs ) const { - samples = samples_; - return *this; + return ( subresource == rhs.subresource ) + && ( offset == rhs.offset ) + && ( extent == rhs.extent ) + && ( memory == rhs.memory ) + && ( memoryOffset == rhs.memoryOffset ) + && ( flags == rhs.flags ); } - ImageCreateInfo& setTiling( ImageTiling tiling_ ) + bool operator!=( SparseImageMemoryBind const& rhs ) const { - tiling = tiling_; - return *this; + return !operator==( rhs ); } - ImageCreateInfo& setUsage( ImageUsageFlags usage_ ) + ImageSubresource subresource; + Offset3D offset; + Extent3D extent; + DeviceMemory memory; + DeviceSize memoryOffset; + SparseMemoryBindFlags flags; + }; + static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" ); + + struct SparseBufferMemoryBindInfo + { + SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr ) + : buffer( buffer_ ) + , bindCount( bindCount_ ) + , pBinds( pBinds_ ) { - usage = usage_; - return *this; } - ImageCreateInfo& setSharingMode( SharingMode sharingMode_ ) + SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) { - sharingMode = sharingMode_; - return *this; + memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); } - ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) + SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) { - queueFamilyIndexCount = queueFamilyIndexCount_; + memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); + return *this; + } + SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; return *this; } - ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) + SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ ) { - pQueueFamilyIndices = pQueueFamilyIndices_; + bindCount = bindCount_; return *this; } - ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ ) + SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) { - initialLayout = initialLayout_; + pBinds = pBinds_; return *this; } - operator const VkImageCreateInfo&() const + operator const VkSparseBufferMemoryBindInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImageCreateInfo const& rhs ) const + bool operator==( SparseBufferMemoryBindInfo const& rhs ) const { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( imageType == rhs.imageType ) - && ( format == rhs.format ) - && ( extent == rhs.extent ) - && ( mipLevels == rhs.mipLevels ) - && ( arrayLayers == rhs.arrayLayers ) - && ( samples == rhs.samples ) - && ( tiling == rhs.tiling ) - && ( usage == rhs.usage ) - && ( sharingMode == rhs.sharingMode ) - && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) - && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) - && ( initialLayout == rhs.initialLayout ); + return ( buffer == rhs.buffer ) + && ( bindCount == rhs.bindCount ) + && ( pBinds == rhs.pBinds ); } - bool operator!=( ImageCreateInfo const& rhs ) const + bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const { return !operator==( rhs ); } - private: - StructureType sType; - - public: - const void* pNext; - ImageCreateFlags flags; - ImageType imageType; - Format format; - Extent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - SampleCountFlagBits samples; - ImageTiling tiling; - ImageUsageFlags usage; - SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - ImageLayout initialLayout; + Buffer buffer; + uint32_t bindCount; + const SparseMemoryBind* pBinds; }; - static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" ); - struct PipelineMultisampleStateCreateInfo + struct SparseImageOpaqueMemoryBindInfo { - PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, Bool32 sampleShadingEnable_ = 0, float minSampleShading_ = 0, const SampleMask* pSampleMask_ = nullptr, Bool32 alphaToCoverageEnable_ = 0, Bool32 alphaToOneEnable_ = 0 ) - : sType( StructureType::ePipelineMultisampleStateCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) - , rasterizationSamples( rasterizationSamples_ ) - , sampleShadingEnable( sampleShadingEnable_ ) - , minSampleShading( minSampleShading_ ) - , pSampleMask( pSampleMask_ ) - , alphaToCoverageEnable( alphaToCoverageEnable_ ) - , alphaToOneEnable( alphaToOneEnable_ ) + SparseImageOpaqueMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr ) + : image( image_ ) + , bindCount( bindCount_ ) + , pBinds( pBinds_ ) { } - PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) + SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); + memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); } - PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) + SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); + memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); return *this; } - PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) - { - rasterizationSamples = rasterizationSamples_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ ) - { - sampleShadingEnable = sampleShadingEnable_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ ) - { - minSampleShading = minSampleShading_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ ) + SparseImageOpaqueMemoryBindInfo& setImage( Image image_ ) { - pSampleMask = pSampleMask_; + image = image_; return *this; } - PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ ) + SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ ) { - alphaToCoverageEnable = alphaToCoverageEnable_; + bindCount = bindCount_; return *this; } - PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ ) + SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) { - alphaToOneEnable = alphaToOneEnable_; + pBinds = pBinds_; return *this; } - operator const VkPipelineMultisampleStateCreateInfo&() const + operator const VkSparseImageOpaqueMemoryBindInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const + bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( rasterizationSamples == rhs.rasterizationSamples ) - && ( sampleShadingEnable == rhs.sampleShadingEnable ) - && ( minSampleShading == rhs.minSampleShading ) - && ( pSampleMask == rhs.pSampleMask ) - && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) - && ( alphaToOneEnable == rhs.alphaToOneEnable ); + return ( image == rhs.image ) + && ( bindCount == rhs.bindCount ) + && ( pBinds == rhs.pBinds ); } - bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const + bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const { return !operator==( rhs ); } - private: - StructureType sType; - - public: - const void* pNext; - PipelineMultisampleStateCreateFlags flags; - SampleCountFlagBits rasterizationSamples; - Bool32 sampleShadingEnable; - float minSampleShading; - const SampleMask* pSampleMask; - Bool32 alphaToCoverageEnable; - Bool32 alphaToOneEnable; + Image image; + uint32_t bindCount; + const SparseMemoryBind* pBinds; }; - static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" ); - struct GraphicsPipelineCreateInfo + struct SparseImageMemoryBindInfo { - GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), uint32_t stageCount_ = 0, const PipelineShaderStageCreateInfo* pStages_ = nullptr, const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, const PipelineViewportStateCreateInfo* pViewportState_ = nullptr, const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, PipelineLayout layout_ = PipelineLayout(), RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 ) - : sType( StructureType::eGraphicsPipelineCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) - , stageCount( stageCount_ ) - , pStages( pStages_ ) - , pVertexInputState( pVertexInputState_ ) - , pInputAssemblyState( pInputAssemblyState_ ) - , pTessellationState( pTessellationState_ ) - , pViewportState( pViewportState_ ) - , pRasterizationState( pRasterizationState_ ) - , pMultisampleState( pMultisampleState_ ) - , pDepthStencilState( pDepthStencilState_ ) - , pColorBlendState( pColorBlendState_ ) - , pDynamicState( pDynamicState_ ) - , layout( layout_ ) - , renderPass( renderPass_ ) - , subpass( subpass_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) + SparseImageMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseImageMemoryBind* pBinds_ = nullptr ) + : image( image_ ) + , bindCount( bindCount_ ) + , pBinds( pBinds_ ) { } - GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) + SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); } - GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) + SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); return *this; } - GraphicsPipelineCreateInfo& setPNext( const void* pNext_ ) + SparseImageMemoryBindInfo& setImage( Image image_ ) { - pNext = pNext_; + image = image_; return *this; } - GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) + SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ ) { - flags = flags_; + bindCount = bindCount_; return *this; } - GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ ) + SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ ) { - stageCount = stageCount_; + pBinds = pBinds_; return *this; } - GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ ) + operator const VkSparseImageMemoryBindInfo&() const { - pStages = pStages_; - return *this; + return *reinterpret_cast(this); } - GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ ) + bool operator==( SparseImageMemoryBindInfo const& rhs ) const { - pVertexInputState = pVertexInputState_; - return *this; + return ( image == rhs.image ) + && ( bindCount == rhs.bindCount ) + && ( pBinds == rhs.pBinds ); } - GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ ) + bool operator!=( SparseImageMemoryBindInfo const& rhs ) const { - pInputAssemblyState = pInputAssemblyState_; - return *this; + return !operator==( rhs ); } - GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ ) + Image image; + uint32_t bindCount; + const SparseImageMemoryBind* pBinds; + }; + static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" ); + + struct BindSparseInfo + { + BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t bufferBindCount_ = 0, const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, uint32_t imageOpaqueBindCount_ = 0, const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, uint32_t imageBindCount_ = 0, const SparseImageMemoryBindInfo* pImageBinds_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr ) + : sType( StructureType::eBindSparseInfo ) + , pNext( nullptr ) + , waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , bufferBindCount( bufferBindCount_ ) + , pBufferBinds( pBufferBinds_ ) + , imageOpaqueBindCount( imageOpaqueBindCount_ ) + , pImageOpaqueBinds( pImageOpaqueBinds_ ) + , imageBindCount( imageBindCount_ ) + , pImageBinds( pImageBinds_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphores( pSignalSemaphores_ ) { - pTessellationState = pTessellationState_; - return *this; } - GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ ) + BindSparseInfo( VkBindSparseInfo const & rhs ) { - pViewportState = pViewportState_; + memcpy( this, &rhs, sizeof( BindSparseInfo ) ); + } + + BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( BindSparseInfo ) ); + return *this; + } + BindSparseInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; return *this; } - GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ ) + BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) { - pRasterizationState = pRasterizationState_; + waitSemaphoreCount = waitSemaphoreCount_; return *this; } - GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ ) + BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) { - pMultisampleState = pMultisampleState_; + pWaitSemaphores = pWaitSemaphores_; return *this; } - GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ ) + BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ ) { - pDepthStencilState = pDepthStencilState_; + bufferBindCount = bufferBindCount_; return *this; } - GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ ) + BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ ) { - pColorBlendState = pColorBlendState_; + pBufferBinds = pBufferBinds_; return *this; } - GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ ) + BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) { - pDynamicState = pDynamicState_; + imageOpaqueBindCount = imageOpaqueBindCount_; return *this; } - GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ ) + BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ ) { - layout = layout_; + pImageOpaqueBinds = pImageOpaqueBinds_; return *this; } - GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ ) + BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ ) { - renderPass = renderPass_; + imageBindCount = imageBindCount_; return *this; } - GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ ) + BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ ) { - subpass = subpass_; + pImageBinds = pImageBinds_; return *this; } - GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) + BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) { - basePipelineHandle = basePipelineHandle_; + signalSemaphoreCount = signalSemaphoreCount_; return *this; } - GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) + BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ ) { - basePipelineIndex = basePipelineIndex_; + pSignalSemaphores = pSignalSemaphores_; return *this; } - operator const VkGraphicsPipelineCreateInfo&() const + operator const VkBindSparseInfo&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( GraphicsPipelineCreateInfo const& rhs ) const + bool operator==( BindSparseInfo const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( stageCount == rhs.stageCount ) - && ( pStages == rhs.pStages ) - && ( pVertexInputState == rhs.pVertexInputState ) - && ( pInputAssemblyState == rhs.pInputAssemblyState ) - && ( pTessellationState == rhs.pTessellationState ) - && ( pViewportState == rhs.pViewportState ) - && ( pRasterizationState == rhs.pRasterizationState ) - && ( pMultisampleState == rhs.pMultisampleState ) - && ( pDepthStencilState == rhs.pDepthStencilState ) - && ( pColorBlendState == rhs.pColorBlendState ) - && ( pDynamicState == rhs.pDynamicState ) - && ( layout == rhs.layout ) - && ( renderPass == rhs.renderPass ) - && ( subpass == rhs.subpass ) - && ( basePipelineHandle == rhs.basePipelineHandle ) - && ( basePipelineIndex == rhs.basePipelineIndex ); + && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) + && ( pWaitSemaphores == rhs.pWaitSemaphores ) + && ( bufferBindCount == rhs.bufferBindCount ) + && ( pBufferBinds == rhs.pBufferBinds ) + && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) + && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) + && ( imageBindCount == rhs.imageBindCount ) + && ( pImageBinds == rhs.pImageBinds ) + && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) + && ( pSignalSemaphores == rhs.pSignalSemaphores ); } - bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const + bool operator!=( BindSparseInfo const& rhs ) const { return !operator==( rhs ); } @@ -17011,8 +16870,722 @@ namespace vk public: const void* pNext; - PipelineCreateFlags flags; - uint32_t stageCount; + uint32_t waitSemaphoreCount; + const Semaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const SparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const SparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const Semaphore* pSignalSemaphores; + }; + static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); + + enum class PipelineStageFlagBits + { + eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, + eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, + eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, + eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, + eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, + eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, + eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, + eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, + eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, + eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT, + eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + eHost = VK_PIPELINE_STAGE_HOST_BIT, + eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, + eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX + }; + + using PipelineStageFlags = Flags; + + VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 ) + { + return PipelineStageFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits ) + { + return ~( PipelineStageFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) + }; + }; + + enum class CommandPoolCreateFlagBits + { + eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, + eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT + }; + + using CommandPoolCreateFlags = Flags; + + VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 ) + { + return CommandPoolCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits ) + { + return ~( CommandPoolCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) + }; + }; + + struct CommandPoolCreateInfo + { + CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 ) + : sType( StructureType::eCommandPoolCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + { + } + + CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); + } + + CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); + return *this; + } + CommandPoolCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + operator const VkCommandPoolCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( CommandPoolCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( queueFamilyIndex == rhs.queueFamilyIndex ); + } + + bool operator!=( CommandPoolCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + CommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; + }; + static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" ); + + enum class CommandPoolResetFlagBits + { + eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT + }; + + using CommandPoolResetFlags = Flags; + + VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 ) + { + return CommandPoolResetFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits ) + { + return ~( CommandPoolResetFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources) + }; + }; + + enum class CommandBufferResetFlagBits + { + eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT + }; + + using CommandBufferResetFlags = Flags; + + VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 ) + { + return CommandBufferResetFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits ) + { + return ~( CommandBufferResetFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources) + }; + }; + + enum class SampleCountFlagBits + { + e1 = VK_SAMPLE_COUNT_1_BIT, + e2 = VK_SAMPLE_COUNT_2_BIT, + e4 = VK_SAMPLE_COUNT_4_BIT, + e8 = VK_SAMPLE_COUNT_8_BIT, + e16 = VK_SAMPLE_COUNT_16_BIT, + e32 = VK_SAMPLE_COUNT_32_BIT, + e64 = VK_SAMPLE_COUNT_64_BIT + }; + + using SampleCountFlags = Flags; + + VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 ) + { + return SampleCountFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits ) + { + return ~( SampleCountFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64) + }; + }; + + struct ImageFormatProperties + { + operator const VkImageFormatProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageFormatProperties const& rhs ) const + { + return ( maxExtent == rhs.maxExtent ) + && ( maxMipLevels == rhs.maxMipLevels ) + && ( maxArrayLayers == rhs.maxArrayLayers ) + && ( sampleCounts == rhs.sampleCounts ) + && ( maxResourceSize == rhs.maxResourceSize ); + } + + bool operator!=( ImageFormatProperties const& rhs ) const + { + return !operator==( rhs ); + } + + Extent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + SampleCountFlags sampleCounts; + DeviceSize maxResourceSize; + }; + static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" ); + + struct ImageCreateInfo + { + ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(), ImageType imageType_ = ImageType::e1D, Format format_ = Format::eUndefined, Extent3D extent_ = Extent3D(), uint32_t mipLevels_ = 0, uint32_t arrayLayers_ = 0, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, ImageLayout initialLayout_ = ImageLayout::eUndefined ) + : sType( StructureType::eImageCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) + , imageType( imageType_ ) + , format( format_ ) + , extent( extent_ ) + , mipLevels( mipLevels_ ) + , arrayLayers( arrayLayers_ ) + , samples( samples_ ) + , tiling( tiling_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) + , initialLayout( initialLayout_ ) + { + } + + ImageCreateInfo( VkImageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); + } + + ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); + return *this; + } + ImageCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageCreateInfo& setFlags( ImageCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + ImageCreateInfo& setImageType( ImageType imageType_ ) + { + imageType = imageType_; + return *this; + } + + ImageCreateInfo& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + ImageCreateInfo& setExtent( Extent3D extent_ ) + { + extent = extent_; + return *this; + } + + ImageCreateInfo& setMipLevels( uint32_t mipLevels_ ) + { + mipLevels = mipLevels_; + return *this; + } + + ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ ) + { + arrayLayers = arrayLayers_; + return *this; + } + + ImageCreateInfo& setSamples( SampleCountFlagBits samples_ ) + { + samples = samples_; + return *this; + } + + ImageCreateInfo& setTiling( ImageTiling tiling_ ) + { + tiling = tiling_; + return *this; + } + + ImageCreateInfo& setUsage( ImageUsageFlags usage_ ) + { + usage = usage_; + return *this; + } + + ImageCreateInfo& setSharingMode( SharingMode sharingMode_ ) + { + sharingMode = sharingMode_; + return *this; + } + + ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ ) + { + initialLayout = initialLayout_; + return *this; + } + + operator const VkImageCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( imageType == rhs.imageType ) + && ( format == rhs.format ) + && ( extent == rhs.extent ) + && ( mipLevels == rhs.mipLevels ) + && ( arrayLayers == rhs.arrayLayers ) + && ( samples == rhs.samples ) + && ( tiling == rhs.tiling ) + && ( usage == rhs.usage ) + && ( sharingMode == rhs.sharingMode ) + && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) + && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) + && ( initialLayout == rhs.initialLayout ); + } + + bool operator!=( ImageCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + ImageCreateFlags flags; + ImageType imageType; + Format format; + Extent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + SampleCountFlagBits samples; + ImageTiling tiling; + ImageUsageFlags usage; + SharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + ImageLayout initialLayout; + }; + static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); + + struct PipelineMultisampleStateCreateInfo + { + PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, Bool32 sampleShadingEnable_ = 0, float minSampleShading_ = 0, const SampleMask* pSampleMask_ = nullptr, Bool32 alphaToCoverageEnable_ = 0, Bool32 alphaToOneEnable_ = 0 ) + : sType( StructureType::ePipelineMultisampleStateCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) + , rasterizationSamples( rasterizationSamples_ ) + , sampleShadingEnable( sampleShadingEnable_ ) + , minSampleShading( minSampleShading_ ) + , pSampleMask( pSampleMask_ ) + , alphaToCoverageEnable( alphaToCoverageEnable_ ) + , alphaToOneEnable( alphaToOneEnable_ ) + { + } + + PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); + } + + PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); + return *this; + } + PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) + { + rasterizationSamples = rasterizationSamples_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ ) + { + sampleShadingEnable = sampleShadingEnable_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ ) + { + minSampleShading = minSampleShading_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ ) + { + pSampleMask = pSampleMask_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ ) + { + alphaToCoverageEnable = alphaToCoverageEnable_; + return *this; + } + + PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ ) + { + alphaToOneEnable = alphaToOneEnable_; + return *this; + } + + operator const VkPipelineMultisampleStateCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( rasterizationSamples == rhs.rasterizationSamples ) + && ( sampleShadingEnable == rhs.sampleShadingEnable ) + && ( minSampleShading == rhs.minSampleShading ) + && ( pSampleMask == rhs.pSampleMask ) + && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) + && ( alphaToOneEnable == rhs.alphaToOneEnable ); + } + + bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + PipelineMultisampleStateCreateFlags flags; + SampleCountFlagBits rasterizationSamples; + Bool32 sampleShadingEnable; + float minSampleShading; + const SampleMask* pSampleMask; + Bool32 alphaToCoverageEnable; + Bool32 alphaToOneEnable; + }; + static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" ); + + struct GraphicsPipelineCreateInfo + { + GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), uint32_t stageCount_ = 0, const PipelineShaderStageCreateInfo* pStages_ = nullptr, const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, const PipelineViewportStateCreateInfo* pViewportState_ = nullptr, const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, PipelineLayout layout_ = PipelineLayout(), RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 ) + : sType( StructureType::eGraphicsPipelineCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) + , stageCount( stageCount_ ) + , pStages( pStages_ ) + , pVertexInputState( pVertexInputState_ ) + , pInputAssemblyState( pInputAssemblyState_ ) + , pTessellationState( pTessellationState_ ) + , pViewportState( pViewportState_ ) + , pRasterizationState( pRasterizationState_ ) + , pMultisampleState( pMultisampleState_ ) + , pDepthStencilState( pDepthStencilState_ ) + , pColorBlendState( pColorBlendState_ ) + , pDynamicState( pDynamicState_ ) + , layout( layout_ ) + , renderPass( renderPass_ ) + , subpass( subpass_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + { + } + + GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); + } + + GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); + return *this; + } + GraphicsPipelineCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ ) + { + stageCount = stageCount_; + return *this; + } + + GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ ) + { + pStages = pStages_; + return *this; + } + + GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ ) + { + pVertexInputState = pVertexInputState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ ) + { + pInputAssemblyState = pInputAssemblyState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ ) + { + pTessellationState = pTessellationState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ ) + { + pViewportState = pViewportState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ ) + { + pRasterizationState = pRasterizationState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ ) + { + pMultisampleState = pMultisampleState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ ) + { + pDepthStencilState = pDepthStencilState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ ) + { + pColorBlendState = pColorBlendState_; + return *this; + } + + GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ ) + { + pDynamicState = pDynamicState_; + return *this; + } + + GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ ) + { + layout = layout_; + return *this; + } + + GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ ) + { + renderPass = renderPass_; + return *this; + } + + GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ ) + { + subpass = subpass_; + return *this; + } + + GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + operator const VkGraphicsPipelineCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( GraphicsPipelineCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( stageCount == rhs.stageCount ) + && ( pStages == rhs.pStages ) + && ( pVertexInputState == rhs.pVertexInputState ) + && ( pInputAssemblyState == rhs.pInputAssemblyState ) + && ( pTessellationState == rhs.pTessellationState ) + && ( pViewportState == rhs.pViewportState ) + && ( pRasterizationState == rhs.pRasterizationState ) + && ( pMultisampleState == rhs.pMultisampleState ) + && ( pDepthStencilState == rhs.pDepthStencilState ) + && ( pColorBlendState == rhs.pColorBlendState ) + && ( pDynamicState == rhs.pDynamicState ) + && ( layout == rhs.layout ) + && ( renderPass == rhs.renderPass ) + && ( subpass == rhs.subpass ) + && ( basePipelineHandle == rhs.basePipelineHandle ) + && ( basePipelineIndex == rhs.basePipelineIndex ); + } + + bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + PipelineCreateFlags flags; + uint32_t stageCount; const PipelineShaderStageCreateInfo* pStages; const PipelineVertexInputStateCreateInfo* pVertexInputState; const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState; @@ -17029,319 +17602,889 @@ namespace vk Pipeline basePipelineHandle; int32_t basePipelineIndex; }; - static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceLimits + { + operator const VkPhysicalDeviceLimits&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceLimits const& rhs ) const + { + return ( maxImageDimension1D == rhs.maxImageDimension1D ) + && ( maxImageDimension2D == rhs.maxImageDimension2D ) + && ( maxImageDimension3D == rhs.maxImageDimension3D ) + && ( maxImageDimensionCube == rhs.maxImageDimensionCube ) + && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) + && ( maxTexelBufferElements == rhs.maxTexelBufferElements ) + && ( maxUniformBufferRange == rhs.maxUniformBufferRange ) + && ( maxStorageBufferRange == rhs.maxStorageBufferRange ) + && ( maxPushConstantsSize == rhs.maxPushConstantsSize ) + && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) + && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) + && ( bufferImageGranularity == rhs.bufferImageGranularity ) + && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) + && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) + && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) + && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) + && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) + && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) + && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) + && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) + && ( maxPerStageResources == rhs.maxPerStageResources ) + && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) + && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) + && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) + && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) + && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) + && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) + && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) + && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) + && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) + && ( maxVertexInputBindings == rhs.maxVertexInputBindings ) + && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) + && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) + && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) + && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) + && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) + && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) + && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents ) + && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) + && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) + && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) + && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) + && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) + && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) + && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) + && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) + && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) + && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) + && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) + && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) + && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) + && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) + && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 ) + && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) + && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ) + && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) + && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) + && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) + && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) + && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) + && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) + && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) + && ( maxViewports == rhs.maxViewports ) + && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 ) + && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 ) + && ( viewportSubPixelBits == rhs.viewportSubPixelBits ) + && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) + && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) + && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) + && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) + && ( minTexelOffset == rhs.minTexelOffset ) + && ( maxTexelOffset == rhs.maxTexelOffset ) + && ( minTexelGatherOffset == rhs.minTexelGatherOffset ) + && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) + && ( minInterpolationOffset == rhs.minInterpolationOffset ) + && ( maxInterpolationOffset == rhs.maxInterpolationOffset ) + && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) + && ( maxFramebufferWidth == rhs.maxFramebufferWidth ) + && ( maxFramebufferHeight == rhs.maxFramebufferHeight ) + && ( maxFramebufferLayers == rhs.maxFramebufferLayers ) + && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) + && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) + && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) + && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) + && ( maxColorAttachments == rhs.maxColorAttachments ) + && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) + && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) + && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) + && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) + && ( storageImageSampleCounts == rhs.storageImageSampleCounts ) + && ( maxSampleMaskWords == rhs.maxSampleMaskWords ) + && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) + && ( timestampPeriod == rhs.timestampPeriod ) + && ( maxClipDistances == rhs.maxClipDistances ) + && ( maxCullDistances == rhs.maxCullDistances ) + && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) + && ( discreteQueuePriorities == rhs.discreteQueuePriorities ) + && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 ) + && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 ) + && ( pointSizeGranularity == rhs.pointSizeGranularity ) + && ( lineWidthGranularity == rhs.lineWidthGranularity ) + && ( strictLines == rhs.strictLines ) + && ( standardSampleLocations == rhs.standardSampleLocations ) + && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) + && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) + && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize ); + } + + bool operator!=( PhysicalDeviceLimits const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + DeviceSize bufferImageGranularity; + DeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + DeviceSize minTexelBufferOffsetAlignment; + DeviceSize minUniformBufferOffsetAlignment; + DeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + SampleCountFlags framebufferColorSampleCounts; + SampleCountFlags framebufferDepthSampleCounts; + SampleCountFlags framebufferStencilSampleCounts; + SampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + SampleCountFlags sampledImageColorSampleCounts; + SampleCountFlags sampledImageIntegerSampleCounts; + SampleCountFlags sampledImageDepthSampleCounts; + SampleCountFlags sampledImageStencilSampleCounts; + SampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + Bool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + Bool32 strictLines; + Bool32 standardSampleLocations; + DeviceSize optimalBufferCopyOffsetAlignment; + DeviceSize optimalBufferCopyRowPitchAlignment; + DeviceSize nonCoherentAtomSize; + }; + static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceProperties + { + operator const VkPhysicalDeviceProperties&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceProperties const& rhs ) const + { + return ( apiVersion == rhs.apiVersion ) + && ( driverVersion == rhs.driverVersion ) + && ( vendorID == rhs.vendorID ) + && ( deviceID == rhs.deviceID ) + && ( deviceType == rhs.deviceType ) + && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 ) + && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) + && ( limits == rhs.limits ) + && ( sparseProperties == rhs.sparseProperties ); + } + + bool operator!=( PhysicalDeviceProperties const& rhs ) const + { + return !operator==( rhs ); + } + + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + PhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + PhysicalDeviceLimits limits; + PhysicalDeviceSparseProperties sparseProperties; + }; + static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceProperties2KHR + { + operator const VkPhysicalDeviceProperties2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceProperties2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( properties == rhs.properties ); + } + + bool operator!=( PhysicalDeviceProperties2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + PhysicalDeviceProperties properties; + }; + static_assert( sizeof( PhysicalDeviceProperties2KHR ) == sizeof( VkPhysicalDeviceProperties2KHR ), "struct and wrapper have different size!" ); + + struct ImageFormatProperties2KHR + { + operator const VkImageFormatProperties2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageFormatProperties2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( imageFormatProperties == rhs.imageFormatProperties ); + } + + bool operator!=( ImageFormatProperties2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + ImageFormatProperties imageFormatProperties; + }; + static_assert( sizeof( ImageFormatProperties2KHR ) == sizeof( VkImageFormatProperties2KHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceSparseImageFormatInfo2KHR + { + PhysicalDeviceSparseImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageUsageFlags usage_ = ImageUsageFlags(), ImageTiling tiling_ = ImageTiling::eOptimal ) + : sType( StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR ) + , pNext( nullptr ) + , format( format_ ) + , type( type_ ) + , samples( samples_ ) + , usage( usage_ ) + , tiling( tiling_ ) + { + } + + PhysicalDeviceSparseImageFormatInfo2KHR( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); + } + + PhysicalDeviceSparseImageFormatInfo2KHR& operator=( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); + return *this; + } + PhysicalDeviceSparseImageFormatInfo2KHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2KHR& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2KHR& setType( ImageType type_ ) + { + type = type_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2KHR& setSamples( SampleCountFlagBits samples_ ) + { + samples = samples_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ ) + { + usage = usage_; + return *this; + } + + PhysicalDeviceSparseImageFormatInfo2KHR& setTiling( ImageTiling tiling_ ) + { + tiling = tiling_; + return *this; + } + + operator const VkPhysicalDeviceSparseImageFormatInfo2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( format == rhs.format ) + && ( type == rhs.type ) + && ( samples == rhs.samples ) + && ( usage == rhs.usage ) + && ( tiling == rhs.tiling ); + } + + bool operator!=( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Format format; + ImageType type; + SampleCountFlagBits samples; + ImageUsageFlags usage; + ImageTiling tiling; + }; + static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2KHR ), "struct and wrapper have different size!" ); + + enum class AttachmentDescriptionFlagBits + { + eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT + }; + + using AttachmentDescriptionFlags = Flags; + + VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 ) + { + return AttachmentDescriptionFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits ) + { + return ~( AttachmentDescriptionFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias) + }; + }; + + struct AttachmentDescription + { + AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(), Format format_ = Format::eUndefined, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, ImageLayout initialLayout_ = ImageLayout::eUndefined, ImageLayout finalLayout_ = ImageLayout::eUndefined ) + : flags( flags_ ) + , format( format_ ) + , samples( samples_ ) + , loadOp( loadOp_ ) + , storeOp( storeOp_ ) + , stencilLoadOp( stencilLoadOp_ ) + , stencilStoreOp( stencilStoreOp_ ) + , initialLayout( initialLayout_ ) + , finalLayout( finalLayout_ ) + { + } + + AttachmentDescription( VkAttachmentDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentDescription ) ); + } + + AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) + { + memcpy( this, &rhs, sizeof( AttachmentDescription ) ); + return *this; + } + AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ ) + { + flags = flags_; + return *this; + } + + AttachmentDescription& setFormat( Format format_ ) + { + format = format_; + return *this; + } + + AttachmentDescription& setSamples( SampleCountFlagBits samples_ ) + { + samples = samples_; + return *this; + } + + AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ ) + { + loadOp = loadOp_; + return *this; + } + + AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ ) + { + storeOp = storeOp_; + return *this; + } + + AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) + { + stencilLoadOp = stencilLoadOp_; + return *this; + } + + AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) + { + stencilStoreOp = stencilStoreOp_; + return *this; + } + + AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ ) + { + initialLayout = initialLayout_; + return *this; + } + + AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ ) + { + finalLayout = finalLayout_; + return *this; + } + + operator const VkAttachmentDescription&() const + { + return *reinterpret_cast(this); + } + + bool operator==( AttachmentDescription const& rhs ) const + { + return ( flags == rhs.flags ) + && ( format == rhs.format ) + && ( samples == rhs.samples ) + && ( loadOp == rhs.loadOp ) + && ( storeOp == rhs.storeOp ) + && ( stencilLoadOp == rhs.stencilLoadOp ) + && ( stencilStoreOp == rhs.stencilStoreOp ) + && ( initialLayout == rhs.initialLayout ) + && ( finalLayout == rhs.finalLayout ); + } + + bool operator!=( AttachmentDescription const& rhs ) const + { + return !operator==( rhs ); + } + + AttachmentDescriptionFlags flags; + Format format; + SampleCountFlagBits samples; + AttachmentLoadOp loadOp; + AttachmentStoreOp storeOp; + AttachmentLoadOp stencilLoadOp; + AttachmentStoreOp stencilStoreOp; + ImageLayout initialLayout; + ImageLayout finalLayout; + }; + static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" ); - struct PhysicalDeviceLimits + enum class StencilFaceFlagBits { - operator const VkPhysicalDeviceLimits&() const + eFront = VK_STENCIL_FACE_FRONT_BIT, + eBack = VK_STENCIL_FACE_BACK_BIT, + eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK + }; + + using StencilFaceFlags = Flags; + + VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 ) + { + return StencilFaceFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits ) + { + return ~( StencilFaceFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack) + }; + }; + + enum class DescriptorPoolCreateFlagBits + { + eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT + }; + + using DescriptorPoolCreateFlags = Flags; + + VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 ) + { + return DescriptorPoolCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits ) + { + return ~( DescriptorPoolCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) + }; + }; + + struct DescriptorPoolCreateInfo + { + DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const DescriptorPoolSize* pPoolSizes_ = nullptr ) + : sType( StructureType::eDescriptorPoolCreateInfo ) + , pNext( nullptr ) + , flags( flags_ ) + , maxSets( maxSets_ ) + , poolSizeCount( poolSizeCount_ ) + , pPoolSizes( pPoolSizes_ ) + { + } + + DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); + } + + DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); + return *this; + } + DescriptorPoolCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ ) + { + maxSets = maxSets_; + return *this; + } + + DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ ) + { + poolSizeCount = poolSizeCount_; + return *this; + } + + DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ ) + { + pPoolSizes = pPoolSizes_; + return *this; + } + + operator const VkDescriptorPoolCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorPoolCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( maxSets == rhs.maxSets ) + && ( poolSizeCount == rhs.poolSizeCount ) + && ( pPoolSizes == rhs.pPoolSizes ); + } + + bool operator!=( DescriptorPoolCreateInfo const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + DescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const DescriptorPoolSize* pPoolSizes; + }; + static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" ); + + enum class DependencyFlagBits + { + eByRegion = VK_DEPENDENCY_BY_REGION_BIT, + eViewLocalKHX = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX, + eDeviceGroupKHX = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX + }; + + using DependencyFlags = Flags; + + VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 ) + { + return DependencyFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits ) + { + return ~( DependencyFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eViewLocalKHX) | VkFlags(DependencyFlagBits::eDeviceGroupKHX) + }; + }; + + struct SubpassDependency + { + SubpassDependency( uint32_t srcSubpass_ = 0, uint32_t dstSubpass_ = 0, PipelineStageFlags srcStageMask_ = PipelineStageFlags(), PipelineStageFlags dstStageMask_ = PipelineStageFlags(), AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), DependencyFlags dependencyFlags_ = DependencyFlags() ) + : srcSubpass( srcSubpass_ ) + , dstSubpass( dstSubpass_ ) + , srcStageMask( srcStageMask_ ) + , dstStageMask( dstStageMask_ ) + , srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , dependencyFlags( dependencyFlags_ ) + { + } + + SubpassDependency( VkSubpassDependency const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDependency ) ); + } + + SubpassDependency& operator=( VkSubpassDependency const & rhs ) + { + memcpy( this, &rhs, sizeof( SubpassDependency ) ); + return *this; + } + SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ ) + { + srcSubpass = srcSubpass_; + return *this; + } + + SubpassDependency& setDstSubpass( uint32_t dstSubpass_ ) + { + dstSubpass = dstSubpass_; + return *this; + } + + SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ ) { - return *reinterpret_cast(this); + srcStageMask = srcStageMask_; + return *this; } - bool operator==( PhysicalDeviceLimits const& rhs ) const + SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ ) { - return ( maxImageDimension1D == rhs.maxImageDimension1D ) - && ( maxImageDimension2D == rhs.maxImageDimension2D ) - && ( maxImageDimension3D == rhs.maxImageDimension3D ) - && ( maxImageDimensionCube == rhs.maxImageDimensionCube ) - && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) - && ( maxTexelBufferElements == rhs.maxTexelBufferElements ) - && ( maxUniformBufferRange == rhs.maxUniformBufferRange ) - && ( maxStorageBufferRange == rhs.maxStorageBufferRange ) - && ( maxPushConstantsSize == rhs.maxPushConstantsSize ) - && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) - && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) - && ( bufferImageGranularity == rhs.bufferImageGranularity ) - && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) - && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) - && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) - && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) - && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) - && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) - && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) - && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) - && ( maxPerStageResources == rhs.maxPerStageResources ) - && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) - && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) - && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) - && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) - && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) - && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) - && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) - && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) - && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) - && ( maxVertexInputBindings == rhs.maxVertexInputBindings ) - && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) - && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) - && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) - && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) - && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) - && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) - && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents ) - && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) - && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) - && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) - && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) - && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) - && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) - && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) - && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) - && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) - && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) - && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) - && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) - && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) - && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) - && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 ) - && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) - && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ) - && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) - && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) - && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) - && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) - && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) - && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) - && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) - && ( maxViewports == rhs.maxViewports ) - && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 ) - && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 ) - && ( viewportSubPixelBits == rhs.viewportSubPixelBits ) - && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) - && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) - && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) - && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) - && ( minTexelOffset == rhs.minTexelOffset ) - && ( maxTexelOffset == rhs.maxTexelOffset ) - && ( minTexelGatherOffset == rhs.minTexelGatherOffset ) - && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) - && ( minInterpolationOffset == rhs.minInterpolationOffset ) - && ( maxInterpolationOffset == rhs.maxInterpolationOffset ) - && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) - && ( maxFramebufferWidth == rhs.maxFramebufferWidth ) - && ( maxFramebufferHeight == rhs.maxFramebufferHeight ) - && ( maxFramebufferLayers == rhs.maxFramebufferLayers ) - && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) - && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) - && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) - && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) - && ( maxColorAttachments == rhs.maxColorAttachments ) - && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) - && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) - && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) - && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) - && ( storageImageSampleCounts == rhs.storageImageSampleCounts ) - && ( maxSampleMaskWords == rhs.maxSampleMaskWords ) - && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) - && ( timestampPeriod == rhs.timestampPeriod ) - && ( maxClipDistances == rhs.maxClipDistances ) - && ( maxCullDistances == rhs.maxCullDistances ) - && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) - && ( discreteQueuePriorities == rhs.discreteQueuePriorities ) - && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 ) - && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 ) - && ( pointSizeGranularity == rhs.pointSizeGranularity ) - && ( lineWidthGranularity == rhs.lineWidthGranularity ) - && ( strictLines == rhs.strictLines ) - && ( standardSampleLocations == rhs.standardSampleLocations ) - && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) - && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) - && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize ); + dstStageMask = dstStageMask_; + return *this; } - bool operator!=( PhysicalDeviceLimits const& rhs ) const + SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ ) { - return !operator==( rhs ); + srcAccessMask = srcAccessMask_; + return *this; } - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferElements; - uint32_t maxUniformBufferRange; - uint32_t maxStorageBufferRange; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxSamplerAllocationCount; - DeviceSize bufferImageGranularity; - DeviceSize sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxPerStageDescriptorInputAttachments; - uint32_t maxPerStageResources; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxDescriptorSetInputAttachments; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessellationGenerationLevel; - uint32_t maxTessellationPatchSize; - uint32_t maxTessellationControlPerVertexInputComponents; - uint32_t maxTessellationControlPerVertexOutputComponents; - uint32_t maxTessellationControlPerPatchOutputComponents; - uint32_t maxTessellationControlTotalOutputComponents; - uint32_t maxTessellationEvaluationInputComponents; - uint32_t maxTessellationEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputAttachments; - uint32_t maxFragmentDualSrcAttachments; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectCount; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - size_t minMemoryMapAlignment; - DeviceSize minTexelBufferOffsetAlignment; - DeviceSize minUniformBufferOffsetAlignment; - DeviceSize minStorageBufferOffsetAlignment; - int32_t minTexelOffset; - uint32_t maxTexelOffset; - int32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - SampleCountFlags framebufferColorSampleCounts; - SampleCountFlags framebufferDepthSampleCounts; - SampleCountFlags framebufferStencilSampleCounts; - SampleCountFlags framebufferNoAttachmentsSampleCounts; - uint32_t maxColorAttachments; - SampleCountFlags sampledImageColorSampleCounts; - SampleCountFlags sampledImageIntegerSampleCounts; - SampleCountFlags sampledImageDepthSampleCounts; - SampleCountFlags sampledImageStencilSampleCounts; - SampleCountFlags storageImageSampleCounts; - uint32_t maxSampleMaskWords; - Bool32 timestampComputeAndGraphics; - float timestampPeriod; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - uint32_t discreteQueuePriorities; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; - Bool32 strictLines; - Bool32 standardSampleLocations; - DeviceSize optimalBufferCopyOffsetAlignment; - DeviceSize optimalBufferCopyRowPitchAlignment; - DeviceSize nonCoherentAtomSize; - }; - static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); + SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ ) + { + dstAccessMask = dstAccessMask_; + return *this; + } - struct PhysicalDeviceProperties - { - operator const VkPhysicalDeviceProperties&() const + SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ ) { - return *reinterpret_cast(this); + dependencyFlags = dependencyFlags_; + return *this; } - bool operator==( PhysicalDeviceProperties const& rhs ) const + operator const VkSubpassDependency&() const { - return ( apiVersion == rhs.apiVersion ) - && ( driverVersion == rhs.driverVersion ) - && ( vendorID == rhs.vendorID ) - && ( deviceID == rhs.deviceID ) - && ( deviceType == rhs.deviceType ) - && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 ) - && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( limits == rhs.limits ) - && ( sparseProperties == rhs.sparseProperties ); + return *reinterpret_cast(this); + } + + bool operator==( SubpassDependency const& rhs ) const + { + return ( srcSubpass == rhs.srcSubpass ) + && ( dstSubpass == rhs.dstSubpass ) + && ( srcStageMask == rhs.srcStageMask ) + && ( dstStageMask == rhs.dstStageMask ) + && ( srcAccessMask == rhs.srcAccessMask ) + && ( dstAccessMask == rhs.dstAccessMask ) + && ( dependencyFlags == rhs.dependencyFlags ); } - bool operator!=( PhysicalDeviceProperties const& rhs ) const + bool operator!=( SubpassDependency const& rhs ) const { return !operator==( rhs ); } - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorID; - uint32_t deviceID; - PhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - PhysicalDeviceLimits limits; - PhysicalDeviceSparseProperties sparseProperties; + uint32_t srcSubpass; + uint32_t dstSubpass; + PipelineStageFlags srcStageMask; + PipelineStageFlags dstStageMask; + AccessFlags srcAccessMask; + AccessFlags dstAccessMask; + DependencyFlags dependencyFlags; }; - static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" ); + static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); - struct PhysicalDeviceProperties2KHR + enum class PresentModeKHR { - operator const VkPhysicalDeviceProperties2KHR&() const + eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, + eMailbox = VK_PRESENT_MODE_MAILBOX_KHR, + eFifo = VK_PRESENT_MODE_FIFO_KHR, + eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR, + eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, + eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR + }; + + enum class ColorSpaceKHR + { + eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, + eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, + eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, + eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, + eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, + eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, + eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, + eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, + eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT, + eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT, + eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, + eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, + ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT + }; + + struct SurfaceFormatKHR + { + operator const VkSurfaceFormatKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceProperties2KHR const& rhs ) const + bool operator==( SurfaceFormatKHR const& rhs ) const { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( properties == rhs.properties ); + return ( format == rhs.format ) + && ( colorSpace == rhs.colorSpace ); } - bool operator!=( PhysicalDeviceProperties2KHR const& rhs ) const + bool operator!=( SurfaceFormatKHR const& rhs ) const { return !operator==( rhs ); } - private: - StructureType sType; - - public: - void* pNext; - PhysicalDeviceProperties properties; + Format format; + ColorSpaceKHR colorSpace; }; - static_assert( sizeof( PhysicalDeviceProperties2KHR ) == sizeof( VkPhysicalDeviceProperties2KHR ), "struct and wrapper have different size!" ); + static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); - struct ImageFormatProperties2KHR + struct SurfaceFormat2KHR { - operator const VkImageFormatProperties2KHR&() const + operator const VkSurfaceFormat2KHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImageFormatProperties2KHR const& rhs ) const + bool operator==( SurfaceFormat2KHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( imageFormatProperties == rhs.imageFormatProperties ); + && ( surfaceFormat == rhs.surfaceFormat ); } - bool operator!=( ImageFormatProperties2KHR const& rhs ) const + bool operator!=( SurfaceFormat2KHR const& rhs ) const { return !operator==( rhs ); } @@ -17351,362 +18494,445 @@ namespace vk public: void* pNext; - ImageFormatProperties imageFormatProperties; + SurfaceFormatKHR surfaceFormat; }; - static_assert( sizeof( ImageFormatProperties2KHR ) == sizeof( VkImageFormatProperties2KHR ), "struct and wrapper have different size!" ); + static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceSparseImageFormatInfo2KHR + enum class DisplayPlaneAlphaFlagBitsKHR { - PhysicalDeviceSparseImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageUsageFlags usage_ = ImageUsageFlags(), ImageTiling tiling_ = ImageTiling::eOptimal ) - : sType( StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR ) - , pNext( nullptr ) - , format( format_ ) - , type( type_ ) - , samples( samples_ ) - , usage( usage_ ) - , tiling( tiling_ ) - { - } + eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, + eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, + ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, + ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR + }; - PhysicalDeviceSparseImageFormatInfo2KHR( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); - } + using DisplayPlaneAlphaFlagsKHR = Flags; - PhysicalDeviceSparseImageFormatInfo2KHR& operator=( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); - return *this; - } - PhysicalDeviceSparseImageFormatInfo2KHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } + VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 ) + { + return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1; + } - PhysicalDeviceSparseImageFormatInfo2KHR& setFormat( Format format_ ) - { - format = format_; - return *this; - } + VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits ) + { + return ~( DisplayPlaneAlphaFlagsKHR( bits ) ); + } - PhysicalDeviceSparseImageFormatInfo2KHR& setType( ImageType type_ ) + template <> struct FlagTraits + { + enum { - type = type_; - return *this; - } + allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) + }; + }; - PhysicalDeviceSparseImageFormatInfo2KHR& setSamples( SampleCountFlagBits samples_ ) + struct DisplayPlaneCapabilitiesKHR + { + operator const VkDisplayPlaneCapabilitiesKHR&() const { - samples = samples_; - return *this; + return *reinterpret_cast(this); } - PhysicalDeviceSparseImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ ) + bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const { - usage = usage_; - return *this; + return ( supportedAlpha == rhs.supportedAlpha ) + && ( minSrcPosition == rhs.minSrcPosition ) + && ( maxSrcPosition == rhs.maxSrcPosition ) + && ( minSrcExtent == rhs.minSrcExtent ) + && ( maxSrcExtent == rhs.maxSrcExtent ) + && ( minDstPosition == rhs.minDstPosition ) + && ( maxDstPosition == rhs.maxDstPosition ) + && ( minDstExtent == rhs.minDstExtent ) + && ( maxDstExtent == rhs.maxDstExtent ); } - PhysicalDeviceSparseImageFormatInfo2KHR& setTiling( ImageTiling tiling_ ) + bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const { - tiling = tiling_; - return *this; + return !operator==( rhs ); } - operator const VkPhysicalDeviceSparseImageFormatInfo2KHR&() const - { - return *reinterpret_cast(this); - } + DisplayPlaneAlphaFlagsKHR supportedAlpha; + Offset2D minSrcPosition; + Offset2D maxSrcPosition; + Extent2D minSrcExtent; + Extent2D maxSrcExtent; + Offset2D minDstPosition; + Offset2D maxDstPosition; + Extent2D minDstExtent; + Extent2D maxDstExtent; + }; + static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" ); - bool operator==( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( format == rhs.format ) - && ( type == rhs.type ) - && ( samples == rhs.samples ) - && ( usage == rhs.usage ) - && ( tiling == rhs.tiling ); - } + enum class CompositeAlphaFlagBitsKHR + { + eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, + ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, + ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, + eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR + }; - bool operator!=( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const - { - return !operator==( rhs ); - } + using CompositeAlphaFlagsKHR = Flags; - private: - StructureType sType; + VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 ) + { + return CompositeAlphaFlagsKHR( bit0 ) | bit1; + } - public: - const void* pNext; - Format format; - ImageType type; - SampleCountFlagBits samples; - ImageUsageFlags usage; - ImageTiling tiling; + VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits ) + { + return ~( CompositeAlphaFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit) + }; }; - static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2KHR ), "struct and wrapper have different size!" ); - enum class AttachmentDescriptionFlagBits + enum class SurfaceTransformFlagBitsKHR { - eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT + eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, + eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, + eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, + eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, + eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, + eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, + eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, + eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, + eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR }; - using AttachmentDescriptionFlags = Flags; + using SurfaceTransformFlagsKHR = Flags; - VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 ) + VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 ) { - return AttachmentDescriptionFlags( bit0 ) | bit1; + return SurfaceTransformFlagsKHR( bit0 ) | bit1; } - VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits ) + VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits ) { - return ~( AttachmentDescriptionFlags( bits ) ); + return ~( SurfaceTransformFlagsKHR( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias) + allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit) }; }; - struct AttachmentDescription + struct DisplayPropertiesKHR { - AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(), Format format_ = Format::eUndefined, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, ImageLayout initialLayout_ = ImageLayout::eUndefined, ImageLayout finalLayout_ = ImageLayout::eUndefined ) - : flags( flags_ ) - , format( format_ ) - , samples( samples_ ) - , loadOp( loadOp_ ) - , storeOp( storeOp_ ) - , stencilLoadOp( stencilLoadOp_ ) - , stencilStoreOp( stencilStoreOp_ ) - , initialLayout( initialLayout_ ) - , finalLayout( finalLayout_ ) + operator const VkDisplayPropertiesKHR&() const { + return *reinterpret_cast(this); } - AttachmentDescription( VkAttachmentDescription const & rhs ) + bool operator==( DisplayPropertiesKHR const& rhs ) const { - memcpy( this, &rhs, sizeof( AttachmentDescription ) ); + return ( display == rhs.display ) + && ( displayName == rhs.displayName ) + && ( physicalDimensions == rhs.physicalDimensions ) + && ( physicalResolution == rhs.physicalResolution ) + && ( supportedTransforms == rhs.supportedTransforms ) + && ( planeReorderPossible == rhs.planeReorderPossible ) + && ( persistentContent == rhs.persistentContent ); } - AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) + bool operator!=( DisplayPropertiesKHR const& rhs ) const { - memcpy( this, &rhs, sizeof( AttachmentDescription ) ); + return !operator==( rhs ); + } + + DisplayKHR display; + const char* displayName; + Extent2D physicalDimensions; + Extent2D physicalResolution; + SurfaceTransformFlagsKHR supportedTransforms; + Bool32 planeReorderPossible; + Bool32 persistentContent; + }; + static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); + + struct DisplaySurfaceCreateInfoKHR + { + DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(), DisplayModeKHR displayMode_ = DisplayModeKHR(), uint32_t planeIndex_ = 0, uint32_t planeStackIndex_ = 0, SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, float globalAlpha_ = 0, DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, Extent2D imageExtent_ = Extent2D() ) + : sType( StructureType::eDisplaySurfaceCreateInfoKHR ) + , pNext( nullptr ) + , flags( flags_ ) + , displayMode( displayMode_ ) + , planeIndex( planeIndex_ ) + , planeStackIndex( planeStackIndex_ ) + , transform( transform_ ) + , globalAlpha( globalAlpha_ ) + , alphaMode( alphaMode_ ) + , imageExtent( imageExtent_ ) + { + } + + DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); + } + + DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); return *this; } - AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ ) + DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { - flags = flags_; + pNext = pNext_; return *this; } - AttachmentDescription& setFormat( Format format_ ) + DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ ) { - format = format_; + flags = flags_; return *this; } - AttachmentDescription& setSamples( SampleCountFlagBits samples_ ) + DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ ) { - samples = samples_; + displayMode = displayMode_; return *this; } - AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ ) + DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ ) { - loadOp = loadOp_; + planeIndex = planeIndex_; return *this; } - AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ ) + DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ ) { - storeOp = storeOp_; + planeStackIndex = planeStackIndex_; return *this; } - AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) + DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ ) { - stencilLoadOp = stencilLoadOp_; + transform = transform_; return *this; } - AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) + DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ ) { - stencilStoreOp = stencilStoreOp_; + globalAlpha = globalAlpha_; return *this; } - AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ ) + DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) { - initialLayout = initialLayout_; + alphaMode = alphaMode_; return *this; } - AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ ) + DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ ) { - finalLayout = finalLayout_; + imageExtent = imageExtent_; return *this; } - operator const VkAttachmentDescription&() const + operator const VkDisplaySurfaceCreateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( AttachmentDescription const& rhs ) const + bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const { - return ( flags == rhs.flags ) - && ( format == rhs.format ) - && ( samples == rhs.samples ) - && ( loadOp == rhs.loadOp ) - && ( storeOp == rhs.storeOp ) - && ( stencilLoadOp == rhs.stencilLoadOp ) - && ( stencilStoreOp == rhs.stencilStoreOp ) - && ( initialLayout == rhs.initialLayout ) - && ( finalLayout == rhs.finalLayout ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( displayMode == rhs.displayMode ) + && ( planeIndex == rhs.planeIndex ) + && ( planeStackIndex == rhs.planeStackIndex ) + && ( transform == rhs.transform ) + && ( globalAlpha == rhs.globalAlpha ) + && ( alphaMode == rhs.alphaMode ) + && ( imageExtent == rhs.imageExtent ); } - bool operator!=( AttachmentDescription const& rhs ) const + bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const { return !operator==( rhs ); } - AttachmentDescriptionFlags flags; - Format format; - SampleCountFlagBits samples; - AttachmentLoadOp loadOp; - AttachmentStoreOp storeOp; - AttachmentLoadOp stencilLoadOp; - AttachmentStoreOp stencilStoreOp; - ImageLayout initialLayout; - ImageLayout finalLayout; + private: + StructureType sType; + + public: + const void* pNext; + DisplaySurfaceCreateFlagsKHR flags; + DisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + SurfaceTransformFlagBitsKHR transform; + float globalAlpha; + DisplayPlaneAlphaFlagBitsKHR alphaMode; + Extent2D imageExtent; }; - static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" ); + static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); - enum class StencilFaceFlagBits + struct SurfaceCapabilitiesKHR { - eFront = VK_STENCIL_FACE_FRONT_BIT, - eBack = VK_STENCIL_FACE_BACK_BIT, - eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK - }; + operator const VkSurfaceCapabilitiesKHR&() const + { + return *reinterpret_cast(this); + } - using StencilFaceFlags = Flags; + bool operator==( SurfaceCapabilitiesKHR const& rhs ) const + { + return ( minImageCount == rhs.minImageCount ) + && ( maxImageCount == rhs.maxImageCount ) + && ( currentExtent == rhs.currentExtent ) + && ( minImageExtent == rhs.minImageExtent ) + && ( maxImageExtent == rhs.maxImageExtent ) + && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) + && ( supportedTransforms == rhs.supportedTransforms ) + && ( currentTransform == rhs.currentTransform ) + && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) + && ( supportedUsageFlags == rhs.supportedUsageFlags ); + } - VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 ) - { - return StencilFaceFlags( bit0 ) | bit1; - } + bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const + { + return !operator==( rhs ); + } - VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits ) - { - return ~( StencilFaceFlags( bits ) ); - } + uint32_t minImageCount; + uint32_t maxImageCount; + Extent2D currentExtent; + Extent2D minImageExtent; + Extent2D maxImageExtent; + uint32_t maxImageArrayLayers; + SurfaceTransformFlagsKHR supportedTransforms; + SurfaceTransformFlagBitsKHR currentTransform; + CompositeAlphaFlagsKHR supportedCompositeAlpha; + ImageUsageFlags supportedUsageFlags; + }; + static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); - template <> struct FlagTraits + struct SurfaceCapabilities2KHR { - enum + operator const VkSurfaceCapabilities2KHR&() const { - allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack) - }; + return *reinterpret_cast(this); + } + + bool operator==( SurfaceCapabilities2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( surfaceCapabilities == rhs.surfaceCapabilities ); + } + + bool operator!=( SurfaceCapabilities2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + SurfaceCapabilitiesKHR surfaceCapabilities; }; + static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); - enum class DescriptorPoolCreateFlagBits + enum class DebugReportFlagBitsEXT { - eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT + eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT, + eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT, + ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, + eError = VK_DEBUG_REPORT_ERROR_BIT_EXT, + eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT }; - using DescriptorPoolCreateFlags = Flags; + using DebugReportFlagsEXT = Flags; - VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 ) + VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 ) { - return DescriptorPoolCreateFlags( bit0 ) | bit1; + return DebugReportFlagsEXT( bit0 ) | bit1; } - VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits ) + VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits ) { - return ~( DescriptorPoolCreateFlags( bits ) ); + return ~( DebugReportFlagsEXT( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) + allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug) }; }; - struct DescriptorPoolCreateInfo + struct DebugReportCallbackCreateInfoEXT { - DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const DescriptorPoolSize* pPoolSizes_ = nullptr ) - : sType( StructureType::eDescriptorPoolCreateInfo ) + DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr ) + : sType( StructureType::eDebugReportCallbackCreateInfoEXT ) , pNext( nullptr ) , flags( flags_ ) - , maxSets( maxSets_ ) - , poolSizeCount( poolSizeCount_ ) - , pPoolSizes( pPoolSizes_ ) + , pfnCallback( pfnCallback_ ) + , pUserData( pUserData_ ) { } - DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) + DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); + memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); } - DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) + DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); + memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); return *this; } - DescriptorPoolCreateInfo& setPNext( const void* pNext_ ) + DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ ) + DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ ) { flags = flags_; return *this; } - DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ ) - { - maxSets = maxSets_; - return *this; - } - - DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ ) + DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) { - poolSizeCount = poolSizeCount_; + pfnCallback = pfnCallback_; return *this; } - DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ ) + DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ ) { - pPoolSizes = pPoolSizes_; + pUserData = pUserData_; return *this; } - operator const VkDescriptorPoolCreateInfo&() const + operator const VkDebugReportCallbackCreateInfoEXT&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( DescriptorPoolCreateInfo const& rhs ) const + bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) - && ( maxSets == rhs.maxSets ) - && ( poolSizeCount == rhs.poolSizeCount ) - && ( pPoolSizes == rhs.pPoolSizes ); + && ( pfnCallback == rhs.pfnCallback ) + && ( pUserData == rhs.pUserData ); } - bool operator!=( DescriptorPoolCreateInfo const& rhs ) const + bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const { return !operator==( rhs ); } @@ -17716,202 +18942,201 @@ namespace vk public: const void* pNext; - DescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const DescriptorPoolSize* pPoolSizes; - }; - static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" ); - - enum class DependencyFlagBits - { - eByRegion = VK_DEPENDENCY_BY_REGION_BIT, - eViewLocalKHX = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX, - eDeviceGroupKHX = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX + DebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; }; + static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" ); - using DependencyFlags = Flags; - - VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 ) - { - return DependencyFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits ) - { - return ~( DependencyFlags( bits ) ); - } - - template <> struct FlagTraits + enum class DebugReportObjectTypeEXT { - enum - { - allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eViewLocalKHX) | VkFlags(DependencyFlagBits::eDeviceGroupKHX) - }; + eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, + eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, + ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, + eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, + eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, + eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, + eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, + eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, + eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, + eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, + eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, + eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, + ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, + ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, + eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, + ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, + eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, + eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, + eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, + eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, + eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, + eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, + eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, + eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, + eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, + eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, + eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, + eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, + eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT }; - struct SubpassDependency + struct DebugMarkerObjectNameInfoEXT { - SubpassDependency( uint32_t srcSubpass_ = 0, uint32_t dstSubpass_ = 0, PipelineStageFlags srcStageMask_ = PipelineStageFlags(), PipelineStageFlags dstStageMask_ = PipelineStageFlags(), AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), DependencyFlags dependencyFlags_ = DependencyFlags() ) - : srcSubpass( srcSubpass_ ) - , dstSubpass( dstSubpass_ ) - , srcStageMask( srcStageMask_ ) - , dstStageMask( dstStageMask_ ) - , srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , dependencyFlags( dependencyFlags_ ) + DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr ) + : sType( StructureType::eDebugMarkerObjectNameInfoEXT ) + , pNext( nullptr ) + , objectType( objectType_ ) + , object( object_ ) + , pObjectName( pObjectName_ ) { } - SubpassDependency( VkSubpassDependency const & rhs ) + DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof( SubpassDependency ) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); } - SubpassDependency& operator=( VkSubpassDependency const & rhs ) + DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof( SubpassDependency ) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); return *this; } - SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ ) + DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ ) { - srcSubpass = srcSubpass_; + pNext = pNext_; return *this; } - SubpassDependency& setDstSubpass( uint32_t dstSubpass_ ) + DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) { - dstSubpass = dstSubpass_; + objectType = objectType_; return *this; } - SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ ) + DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ ) { - srcStageMask = srcStageMask_; + object = object_; return *this; } - SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ ) + DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ ) { - dstStageMask = dstStageMask_; + pObjectName = pObjectName_; return *this; } - SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ ) + operator const VkDebugMarkerObjectNameInfoEXT&() const { - srcAccessMask = srcAccessMask_; - return *this; + return *reinterpret_cast(this); } - SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ ) + bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const { - dstAccessMask = dstAccessMask_; - return *this; + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( objectType == rhs.objectType ) + && ( object == rhs.object ) + && ( pObjectName == rhs.pObjectName ); } - SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ ) + bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const { - dependencyFlags = dependencyFlags_; - return *this; + return !operator==( rhs ); } - operator const VkSubpassDependency&() const - { - return *reinterpret_cast(this); - } + private: + StructureType sType; - bool operator==( SubpassDependency const& rhs ) const + public: + const void* pNext; + DebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; + }; + static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" ); + + struct DebugMarkerObjectTagInfoEXT + { + DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr ) + : sType( StructureType::eDebugMarkerObjectTagInfoEXT ) + , pNext( nullptr ) + , objectType( objectType_ ) + , object( object_ ) + , tagName( tagName_ ) + , tagSize( tagSize_ ) + , pTag( pTag_ ) { - return ( srcSubpass == rhs.srcSubpass ) - && ( dstSubpass == rhs.dstSubpass ) - && ( srcStageMask == rhs.srcStageMask ) - && ( dstStageMask == rhs.dstStageMask ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ) - && ( dependencyFlags == rhs.dependencyFlags ); } - bool operator!=( SubpassDependency const& rhs ) const + DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) { - return !operator==( rhs ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); } - uint32_t srcSubpass; - uint32_t dstSubpass; - PipelineStageFlags srcStageMask; - PipelineStageFlags dstStageMask; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - DependencyFlags dependencyFlags; - }; - static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); - - enum class PresentModeKHR - { - eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, - eMailbox = VK_PRESENT_MODE_MAILBOX_KHR, - eFifo = VK_PRESENT_MODE_FIFO_KHR, - eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR, - eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, - eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR - }; - - enum class ColorSpaceKHR - { - eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, - eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, - eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, - eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, - eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, - eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, - eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, - eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, - eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT, - eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT, - eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, - eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, - ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT - }; + DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); + return *this; + } + DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } - struct SurfaceFormatKHR - { - operator const VkSurfaceFormatKHR&() const + DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) { - return *reinterpret_cast(this); + objectType = objectType_; + return *this; } - bool operator==( SurfaceFormatKHR const& rhs ) const + DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ ) { - return ( format == rhs.format ) - && ( colorSpace == rhs.colorSpace ); + object = object_; + return *this; } - bool operator!=( SurfaceFormatKHR const& rhs ) const + DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ ) { - return !operator==( rhs ); + tagName = tagName_; + return *this; } - Format format; - ColorSpaceKHR colorSpace; - }; - static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); + DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ ) + { + tagSize = tagSize_; + return *this; + } - struct SurfaceFormat2KHR - { - operator const VkSurfaceFormat2KHR&() const + DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ ) { - return *reinterpret_cast(this); + pTag = pTag_; + return *this; } - bool operator==( SurfaceFormat2KHR const& rhs ) const + operator const VkDebugMarkerObjectTagInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( surfaceFormat == rhs.surfaceFormat ); + && ( objectType == rhs.objectType ) + && ( object == rhs.object ) + && ( tagName == rhs.tagName ) + && ( tagSize == rhs.tagSize ) + && ( pTag == rhs.pTag ); } - bool operator!=( SurfaceFormat2KHR const& rhs ) const + bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const { return !operator==( rhs ); } @@ -17920,270 +19145,207 @@ namespace vk StructureType sType; public: - void* pNext; - SurfaceFormatKHR surfaceFormat; + const void* pNext; + DebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; }; - static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); + static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" ); - enum class DisplayPlaneAlphaFlagBitsKHR + enum class RasterizationOrderAMD { - eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, - eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, - ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, - ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR + eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD, + eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD }; - using DisplayPlaneAlphaFlagsKHR = Flags; - - VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 ) - { - return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits ) - { - return ~( DisplayPlaneAlphaFlagsKHR( bits ) ); - } - - template <> struct FlagTraits + struct PipelineRasterizationStateRasterizationOrderAMD { - enum + PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict ) + : sType( StructureType::ePipelineRasterizationStateRasterizationOrderAMD ) + , pNext( nullptr ) + , rasterizationOrder( rasterizationOrder_ ) { - allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) - }; - }; + } - struct DisplayPlaneCapabilitiesKHR - { - operator const VkDisplayPlaneCapabilitiesKHR&() const + PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) { - return *reinterpret_cast(this); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); } - bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const + PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) { - return ( supportedAlpha == rhs.supportedAlpha ) - && ( minSrcPosition == rhs.minSrcPosition ) - && ( maxSrcPosition == rhs.maxSrcPosition ) - && ( minSrcExtent == rhs.minSrcExtent ) - && ( maxSrcExtent == rhs.maxSrcExtent ) - && ( minDstPosition == rhs.minDstPosition ) - && ( maxDstPosition == rhs.maxDstPosition ) - && ( minDstExtent == rhs.minDstExtent ) - && ( maxDstExtent == rhs.maxDstExtent ); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); + return *this; } - - bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const + PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ ) { - return !operator==( rhs ); + pNext = pNext_; + return *this; } - DisplayPlaneAlphaFlagsKHR supportedAlpha; - Offset2D minSrcPosition; - Offset2D maxSrcPosition; - Extent2D minSrcExtent; - Extent2D maxSrcExtent; - Offset2D minDstPosition; - Offset2D maxDstPosition; - Extent2D minDstExtent; - Extent2D maxDstExtent; - }; - static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" ); + PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ ) + { + rasterizationOrder = rasterizationOrder_; + return *this; + } - enum class CompositeAlphaFlagBitsKHR - { - eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, - ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, - ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, - eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR - }; + operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const + { + return *reinterpret_cast(this); + } - using CompositeAlphaFlagsKHR = Flags; + bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( rasterizationOrder == rhs.rasterizationOrder ); + } - VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 ) - { - return CompositeAlphaFlagsKHR( bit0 ) | bit1; - } + bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const + { + return !operator==( rhs ); + } - VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits ) - { - return ~( CompositeAlphaFlagsKHR( bits ) ); - } + private: + StructureType sType; - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit) - }; + public: + const void* pNext; + RasterizationOrderAMD rasterizationOrder; }; + static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" ); - enum class SurfaceTransformFlagBitsKHR + enum class ExternalMemoryHandleTypeFlagBitsNV { - eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, - eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, - eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, - eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, - eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, - eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, - eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, - eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, - eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR + eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, + eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, + eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, + eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV }; - using SurfaceTransformFlagsKHR = Flags; + using ExternalMemoryHandleTypeFlagsNV = Flags; - VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 ) + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 ) { - return SurfaceTransformFlagsKHR( bit0 ) | bit1; + return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1; } - VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits ) + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits ) { - return ~( SurfaceTransformFlagsKHR( bits ) ); + return ~( ExternalMemoryHandleTypeFlagsNV( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit) + allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) }; }; - struct DisplayPropertiesKHR - { - operator const VkDisplayPropertiesKHR&() const - { - return *reinterpret_cast(this); - } - - bool operator==( DisplayPropertiesKHR const& rhs ) const - { - return ( display == rhs.display ) - && ( displayName == rhs.displayName ) - && ( physicalDimensions == rhs.physicalDimensions ) - && ( physicalResolution == rhs.physicalResolution ) - && ( supportedTransforms == rhs.supportedTransforms ) - && ( planeReorderPossible == rhs.planeReorderPossible ) - && ( persistentContent == rhs.persistentContent ); - } - - bool operator!=( DisplayPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - DisplayKHR display; - const char* displayName; - Extent2D physicalDimensions; - Extent2D physicalResolution; - SurfaceTransformFlagsKHR supportedTransforms; - Bool32 planeReorderPossible; - Bool32 persistentContent; - }; - static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); - - struct DisplaySurfaceCreateInfoKHR + struct ExternalMemoryImageCreateInfoNV { - DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(), DisplayModeKHR displayMode_ = DisplayModeKHR(), uint32_t planeIndex_ = 0, uint32_t planeStackIndex_ = 0, SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, float globalAlpha_ = 0, DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, Extent2D imageExtent_ = Extent2D() ) - : sType( StructureType::eDisplaySurfaceCreateInfoKHR ) + ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) + : sType( StructureType::eExternalMemoryImageCreateInfoNV ) , pNext( nullptr ) - , flags( flags_ ) - , displayMode( displayMode_ ) - , planeIndex( planeIndex_ ) - , planeStackIndex( planeStackIndex_ ) - , transform( transform_ ) - , globalAlpha( globalAlpha_ ) - , alphaMode( alphaMode_ ) - , imageExtent( imageExtent_ ) + , handleTypes( handleTypes_ ) { } - DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) + ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); } - DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) + ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); return *this; } - DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ ) + ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ ) + ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) { - flags = flags_; + handleTypes = handleTypes_; return *this; } - DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ ) + operator const VkExternalMemoryImageCreateInfoNV&() const { - displayMode = displayMode_; - return *this; + return *reinterpret_cast(this); } - DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ ) + bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const { - planeIndex = planeIndex_; - return *this; + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); } - DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ ) + bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const { - planeStackIndex = planeStackIndex_; - return *this; + return !operator==( rhs ); } - DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ ) + private: + StructureType sType; + + public: + const void* pNext; + ExternalMemoryHandleTypeFlagsNV handleTypes; + }; + static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" ); + + struct ExportMemoryAllocateInfoNV + { + ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) + : sType( StructureType::eExportMemoryAllocateInfoNV ) + , pNext( nullptr ) + , handleTypes( handleTypes_ ) { - transform = transform_; - return *this; } - DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ ) + ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) { - globalAlpha = globalAlpha_; - return *this; + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); } - DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) + ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) { - alphaMode = alphaMode_; + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); + return *this; + } + ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; return *this; } - DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ ) + ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) { - imageExtent = imageExtent_; + handleTypes = handleTypes_; return *this; } - operator const VkDisplaySurfaceCreateInfoKHR&() const + operator const VkExportMemoryAllocateInfoNV&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const + bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( displayMode == rhs.displayMode ) - && ( planeIndex == rhs.planeIndex ) - && ( planeStackIndex == rhs.planeStackIndex ) - && ( transform == rhs.transform ) - && ( globalAlpha == rhs.globalAlpha ) - && ( alphaMode == rhs.alphaMode ) - && ( imageExtent == rhs.imageExtent ); + && ( handleTypes == rhs.handleTypes ); } - bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const + bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const { return !operator==( rhs ); } @@ -18193,71 +19355,63 @@ namespace vk public: const void* pNext; - DisplaySurfaceCreateFlagsKHR flags; - DisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - SurfaceTransformFlagBitsKHR transform; - float globalAlpha; - DisplayPlaneAlphaFlagBitsKHR alphaMode; - Extent2D imageExtent; + ExternalMemoryHandleTypeFlagsNV handleTypes; }; - static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); - struct SurfaceCapabilitiesKHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportMemoryWin32HandleInfoNV { - operator const VkSurfaceCapabilitiesKHR&() const + ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 ) + : sType( StructureType::eImportMemoryWin32HandleInfoNV ) + , pNext( nullptr ) + , handleType( handleType_ ) + , handle( handle_ ) { - return *reinterpret_cast(this); } - bool operator==( SurfaceCapabilitiesKHR const& rhs ) const + ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) { - return ( minImageCount == rhs.minImageCount ) - && ( maxImageCount == rhs.maxImageCount ) - && ( currentExtent == rhs.currentExtent ) - && ( minImageExtent == rhs.minImageExtent ) - && ( maxImageExtent == rhs.maxImageExtent ) - && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) - && ( supportedTransforms == rhs.supportedTransforms ) - && ( currentTransform == rhs.currentTransform ) - && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) - && ( supportedUsageFlags == rhs.supportedUsageFlags ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); } - bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const + ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) { - return !operator==( rhs ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); + return *this; + } + ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; } - uint32_t minImageCount; - uint32_t maxImageCount; - Extent2D currentExtent; - Extent2D minImageExtent; - Extent2D maxImageExtent; - uint32_t maxImageArrayLayers; - SurfaceTransformFlagsKHR supportedTransforms; - SurfaceTransformFlagBitsKHR currentTransform; - CompositeAlphaFlagsKHR supportedCompositeAlpha; - ImageUsageFlags supportedUsageFlags; - }; - static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); + ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ ) + { + handleType = handleType_; + return *this; + } - struct SurfaceCapabilities2KHR - { - operator const VkSurfaceCapabilities2KHR&() const + ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ ) { - return *reinterpret_cast(this); + handle = handle_; + return *this; } - bool operator==( SurfaceCapabilities2KHR const& rhs ) const + operator const VkImportMemoryWin32HandleInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( surfaceCapabilities == rhs.surfaceCapabilities ); + && ( handleType == rhs.handleType ) + && ( handle == rhs.handle ); } - bool operator!=( SurfaceCapabilities2KHR const& rhs ) const + bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const { return !operator==( rhs ); } @@ -18266,100 +19420,125 @@ namespace vk StructureType sType; public: - void* pNext; - SurfaceCapabilitiesKHR surfaceCapabilities; + const void* pNext; + ExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; }; - static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - enum class DebugReportFlagBitsEXT + enum class ExternalMemoryFeatureFlagBitsNV { - eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT, - eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT, - ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - eError = VK_DEBUG_REPORT_ERROR_BIT_EXT, - eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT + eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, + eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, + eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV }; - using DebugReportFlagsEXT = Flags; + using ExternalMemoryFeatureFlagsNV = Flags; - VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 ) + VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 ) { - return DebugReportFlagsEXT( bit0 ) | bit1; + return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1; } - VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits ) + VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits ) { - return ~( DebugReportFlagsEXT( bits ) ); + return ~( ExternalMemoryFeatureFlagsNV( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug) + allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable) }; }; - struct DebugReportCallbackCreateInfoEXT + struct ExternalImageFormatPropertiesNV { - DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr ) - : sType( StructureType::eDebugReportCallbackCreateInfoEXT ) - , pNext( nullptr ) - , flags( flags_ ) - , pfnCallback( pfnCallback_ ) - , pUserData( pUserData_ ) + operator const VkExternalImageFormatPropertiesNV&() const { + return *reinterpret_cast(this); } - DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) + bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const { - memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); + return ( imageFormatProperties == rhs.imageFormatProperties ) + && ( externalMemoryFeatures == rhs.externalMemoryFeatures ) + && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) + && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); } - DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) + bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const { - memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); - return *this; + return !operator==( rhs ); } - DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ ) + + ImageFormatProperties imageFormatProperties; + ExternalMemoryFeatureFlagsNV externalMemoryFeatures; + ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; + ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; + }; + static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" ); + + enum class ValidationCheckEXT + { + eAll = VK_VALIDATION_CHECK_ALL_EXT, + eShaders = VK_VALIDATION_CHECK_SHADERS_EXT + }; + + struct ValidationFlagsEXT + { + ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) + : sType( StructureType::eValidationFlagsEXT ) + , pNext( nullptr ) + , disabledValidationCheckCount( disabledValidationCheckCount_ ) + , pDisabledValidationChecks( pDisabledValidationChecks_ ) { - pNext = pNext_; - return *this; } - DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ ) + ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) { - flags = flags_; + memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); + } + + ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); + return *this; + } + ValidationFlagsEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; return *this; } - DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) + ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ ) { - pfnCallback = pfnCallback_; + disabledValidationCheckCount = disabledValidationCheckCount_; return *this; } - DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ ) + ValidationFlagsEXT& setPDisabledValidationChecks( ValidationCheckEXT* pDisabledValidationChecks_ ) { - pUserData = pUserData_; + pDisabledValidationChecks = pDisabledValidationChecks_; return *this; } - operator const VkDebugReportCallbackCreateInfoEXT&() const + operator const VkValidationFlagsEXT&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const + bool operator==( ValidationFlagsEXT const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pfnCallback == rhs.pfnCallback ) - && ( pUserData == rhs.pUserData ); + && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) + && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); } - bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const + bool operator!=( ValidationFlagsEXT const& rhs ) const { return !operator==( rhs ); } @@ -18369,268 +19548,274 @@ namespace vk public: const void* pNext; - DebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData; + uint32_t disabledValidationCheckCount; + ValidationCheckEXT* pDisabledValidationChecks; }; - static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" ); + static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); - enum class DebugReportObjectTypeEXT + enum class IndirectCommandsLayoutUsageFlagBitsNVX { - eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, - ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, - eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, - eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, - eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, - eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, - eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, - ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, - ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, - eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, - eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, - eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, - eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, - eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, - eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, - eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, - eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, - eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, - eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, - eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT + eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX, + eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX, + eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX, + eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX }; - struct DebugMarkerObjectNameInfoEXT + using IndirectCommandsLayoutUsageFlagsNVX = Flags; + + VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 ) { - DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr ) - : sType( StructureType::eDebugMarkerObjectNameInfoEXT ) - , pNext( nullptr ) - , objectType( objectType_ ) - , object( object_ ) - , pObjectName( pObjectName_ ) + return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits ) + { + return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) ); + } + + template <> struct FlagTraits + { + enum { - } + allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) + }; + }; - DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) + enum class ObjectEntryUsageFlagBitsNVX + { + eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX, + eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX + }; + + using ObjectEntryUsageFlagsNVX = Flags; + + VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 ) + { + return ObjectEntryUsageFlagsNVX( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits ) + { + return ~( ObjectEntryUsageFlagsNVX( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute) + }; + }; + + enum class IndirectCommandsTokenTypeNVX + { + ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, + eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX, + eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX, + eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX, + ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX, + eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, + eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, + eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX + }; + + struct IndirectCommandsTokenNVX + { + IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0 ) + : tokenType( tokenType_ ) + , buffer( buffer_ ) + , offset( offset_ ) { - memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); } - DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) + IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) { - memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); - return *this; + memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); } - DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ ) + + IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) { - pNext = pNext_; + memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); return *this; } - - DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) + IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) { - objectType = objectType_; + tokenType = tokenType_; return *this; } - DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ ) + IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ ) { - object = object_; + buffer = buffer_; return *this; } - DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ ) + IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ ) { - pObjectName = pObjectName_; + offset = offset_; return *this; } - operator const VkDebugMarkerObjectNameInfoEXT&() const + operator const VkIndirectCommandsTokenNVX&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const + bool operator==( IndirectCommandsTokenNVX const& rhs ) const { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectType == rhs.objectType ) - && ( object == rhs.object ) - && ( pObjectName == rhs.pObjectName ); + return ( tokenType == rhs.tokenType ) + && ( buffer == rhs.buffer ) + && ( offset == rhs.offset ); } - bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const + bool operator!=( IndirectCommandsTokenNVX const& rhs ) const { return !operator==( rhs ); } - private: - StructureType sType; - - public: - const void* pNext; - DebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName; + IndirectCommandsTokenTypeNVX tokenType; + Buffer buffer; + DeviceSize offset; }; - static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" ); + static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" ); - struct DebugMarkerObjectTagInfoEXT + struct IndirectCommandsLayoutTokenNVX { - DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr ) - : sType( StructureType::eDebugMarkerObjectTagInfoEXT ) - , pNext( nullptr ) - , objectType( objectType_ ) - , object( object_ ) - , tagName( tagName_ ) - , tagSize( tagSize_ ) - , pTag( pTag_ ) - { - } - - DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) + IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, uint32_t bindingUnit_ = 0, uint32_t dynamicCount_ = 0, uint32_t divisor_ = 0 ) + : tokenType( tokenType_ ) + , bindingUnit( bindingUnit_ ) + , dynamicCount( dynamicCount_ ) + , divisor( divisor_ ) { - memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); } - DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); - return *this; - } - DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ ) + IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) { - pNext = pNext_; - return *this; + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); } - DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) + IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) { - objectType = objectType_; + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); return *this; } - - DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ ) + IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) { - object = object_; + tokenType = tokenType_; return *this; } - DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ ) + IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ ) { - tagName = tagName_; + bindingUnit = bindingUnit_; return *this; } - DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ ) + IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ ) { - tagSize = tagSize_; + dynamicCount = dynamicCount_; return *this; } - DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ ) + IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ ) { - pTag = pTag_; + divisor = divisor_; return *this; } - operator const VkDebugMarkerObjectTagInfoEXT&() const + operator const VkIndirectCommandsLayoutTokenNVX&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const + bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectType == rhs.objectType ) - && ( object == rhs.object ) - && ( tagName == rhs.tagName ) - && ( tagSize == rhs.tagSize ) - && ( pTag == rhs.pTag ); + return ( tokenType == rhs.tokenType ) + && ( bindingUnit == rhs.bindingUnit ) + && ( dynamicCount == rhs.dynamicCount ) + && ( divisor == rhs.divisor ); } - bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const + bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const { return !operator==( rhs ); } - private: - StructureType sType; - - public: - const void* pNext; - DebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag; - }; - static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" ); - - enum class RasterizationOrderAMD - { - eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD, - eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD + IndirectCommandsTokenTypeNVX tokenType; + uint32_t bindingUnit; + uint32_t dynamicCount; + uint32_t divisor; }; + static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" ); - struct PipelineRasterizationStateRasterizationOrderAMD + struct IndirectCommandsLayoutCreateInfoNVX { - PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict ) - : sType( StructureType::ePipelineRasterizationStateRasterizationOrderAMD ) + IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) + : sType( StructureType::eIndirectCommandsLayoutCreateInfoNVX ) , pNext( nullptr ) - , rasterizationOrder( rasterizationOrder_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , flags( flags_ ) + , tokenCount( tokenCount_ ) + , pTokens( pTokens_ ) { } - PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) + IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); } - PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) + IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); return *this; } - PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ ) + IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ ) + IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) { - rasterizationOrder = rasterizationOrder_; + pipelineBindPoint = pipelineBindPoint_; return *this; } - operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const + IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ ) { - return *reinterpret_cast(this); + flags = flags_; + return *this; } - bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const + IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ ) + { + tokenCount = tokenCount_; + return *this; + } + + IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ ) + { + pTokens = pTokens_; + return *this; + } + + operator const VkIndirectCommandsLayoutCreateInfoNVX&() const + { + return *reinterpret_cast(this); + } + + bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( rasterizationOrder == rhs.rasterizationOrder ); + && ( pipelineBindPoint == rhs.pipelineBindPoint ) + && ( flags == rhs.flags ) + && ( tokenCount == rhs.tokenCount ) + && ( pTokens == rhs.pTokens ); } - bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const + bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const { return !operator==( rhs ); } @@ -18640,139 +19825,130 @@ namespace vk public: const void* pNext; - RasterizationOrderAMD rasterizationOrder; - }; - static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" ); - - enum class ExternalMemoryHandleTypeFlagBitsNV - { - eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, - eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, - eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, - eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV + PipelineBindPoint pipelineBindPoint; + IndirectCommandsLayoutUsageFlagsNVX flags; + uint32_t tokenCount; + const IndirectCommandsLayoutTokenNVX* pTokens; }; + static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" ); - using ExternalMemoryHandleTypeFlagsNV = Flags; - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 ) - { - return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits ) - { - return ~( ExternalMemoryHandleTypeFlagsNV( bits ) ); - } - - template <> struct FlagTraits + enum class ObjectEntryTypeNVX { - enum - { - allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) - }; + eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, + ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX, + eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX, + eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX, + ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX }; - struct ExternalMemoryImageCreateInfoNV + struct ObjectTableCreateInfoNVX { - ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) - : sType( StructureType::eExternalMemoryImageCreateInfoNV ) + ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, const uint32_t* pObjectEntryCounts_ = nullptr, const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, uint32_t maxUniformBuffersPerDescriptor_ = 0, uint32_t maxStorageBuffersPerDescriptor_ = 0, uint32_t maxStorageImagesPerDescriptor_ = 0, uint32_t maxSampledImagesPerDescriptor_ = 0, uint32_t maxPipelineLayouts_ = 0 ) + : sType( StructureType::eObjectTableCreateInfoNVX ) , pNext( nullptr ) - , handleTypes( handleTypes_ ) + , objectCount( objectCount_ ) + , pObjectEntryTypes( pObjectEntryTypes_ ) + , pObjectEntryCounts( pObjectEntryCounts_ ) + , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) + , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ ) + , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ ) + , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ ) + , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ ) + , maxPipelineLayouts( maxPipelineLayouts_ ) { } - ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) + ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); + memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); } - ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) + ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); + memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); return *this; } - ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ ) + ObjectTableCreateInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) + ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ ) { - handleTypes = handleTypes_; + objectCount = objectCount_; return *this; } - operator const VkExternalMemoryImageCreateInfoNV&() const + ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ ) { - return *reinterpret_cast(this); + pObjectEntryTypes = pObjectEntryTypes_; + return *this; } - bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const + ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ ) { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); + pObjectEntryCounts = pObjectEntryCounts_; + return *this; } - bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const + ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ ) { - return !operator==( rhs ); + pObjectEntryUsageFlags = pObjectEntryUsageFlags_; + return *this; } - private: - StructureType sType; - - public: - const void* pNext; - ExternalMemoryHandleTypeFlagsNV handleTypes; - }; - static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" ); - - struct ExportMemoryAllocateInfoNV - { - ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) - : sType( StructureType::eExportMemoryAllocateInfoNV ) - , pNext( nullptr ) - , handleTypes( handleTypes_ ) + ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ ) { + maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_; + return *this; } - ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) + ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ ) { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); + maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_; + return *this; } - ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) + ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ ) { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); + maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_; return *this; } - ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ ) + + ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ ) { - pNext = pNext_; + maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_; return *this; } - ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) + ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ ) { - handleTypes = handleTypes_; + maxPipelineLayouts = maxPipelineLayouts_; return *this; } - operator const VkExportMemoryAllocateInfoNV&() const + operator const VkObjectTableCreateInfoNVX&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const + bool operator==( ObjectTableCreateInfoNVX const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); + && ( objectCount == rhs.objectCount ) + && ( pObjectEntryTypes == rhs.pObjectEntryTypes ) + && ( pObjectEntryCounts == rhs.pObjectEntryCounts ) + && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags ) + && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor ) + && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor ) + && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor ) + && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor ) + && ( maxPipelineLayouts == rhs.maxPipelineLayouts ); } - bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const + bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const { return !operator==( rhs ); } @@ -18782,467 +19958,571 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagsNV handleTypes; + uint32_t objectCount; + const ObjectEntryTypeNVX* pObjectEntryTypes; + const uint32_t* pObjectEntryCounts; + const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; + uint32_t maxUniformBuffersPerDescriptor; + uint32_t maxStorageBuffersPerDescriptor; + uint32_t maxStorageImagesPerDescriptor; + uint32_t maxSampledImagesPerDescriptor; + uint32_t maxPipelineLayouts; }; - static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); + static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" ); -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ImportMemoryWin32HandleInfoNV + struct ObjectTableEntryNVX { - ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 ) - : sType( StructureType::eImportMemoryWin32HandleInfoNV ) - , pNext( nullptr ) - , handleType( handleType_ ) - , handle( handle_ ) + ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() ) + : type( type_ ) + , flags( flags_ ) { } - ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) + ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); + memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); } - ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); - return *this; - } - ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) + ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) { - pNext = pNext_; + memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); return *this; } - - ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ ) + ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ ) { - handleType = handleType_; + type = type_; return *this; } - ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ ) + ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) { - handle = handle_; + flags = flags_; return *this; } - operator const VkImportMemoryWin32HandleInfoNV&() const + operator const VkObjectTableEntryNVX&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const + bool operator==( ObjectTableEntryNVX const& rhs ) const { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ); + return ( type == rhs.type ) + && ( flags == rhs.flags ); } - bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const + bool operator!=( ObjectTableEntryNVX const& rhs ) const { return !operator==( rhs ); } - private: - StructureType sType; - - public: - const void* pNext; - ExternalMemoryHandleTypeFlagsNV handleType; - HANDLE handle; + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; }; - static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" ); - enum class ExternalMemoryFeatureFlagBitsNV + struct ObjectTablePipelineEntryNVX { - eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, - eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, - eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV - }; + ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Pipeline pipeline_ = Pipeline() ) + : type( type_ ) + , flags( flags_ ) + , pipeline( pipeline_ ) + { + } - using ExternalMemoryFeatureFlagsNV = Flags; + ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); + } - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 ) - { - return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1; - } + ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); + return *this; + } + ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ ) + { + type = type_; + return *this; + } - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits ) - { - return ~( ExternalMemoryFeatureFlagsNV( bits ) ); - } + ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } - template <> struct FlagTraits - { - enum + ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ ) { - allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable) - }; - }; + pipeline = pipeline_; + return *this; + } - struct ExternalImageFormatPropertiesNV - { - operator const VkExternalImageFormatPropertiesNV&() const + operator const VkObjectTablePipelineEntryNVX&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const + bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const { - return ( imageFormatProperties == rhs.imageFormatProperties ) - && ( externalMemoryFeatures == rhs.externalMemoryFeatures ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); + return ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( pipeline == rhs.pipeline ); } - bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const + bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const { return !operator==( rhs ); } - ImageFormatProperties imageFormatProperties; - ExternalMemoryFeatureFlagsNV externalMemoryFeatures; - ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; - ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; - }; - static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" ); - - enum class ValidationCheckEXT - { - eAll = VK_VALIDATION_CHECK_ALL_EXT, - eShaders = VK_VALIDATION_CHECK_SHADERS_EXT + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + Pipeline pipeline; }; + static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" ); - struct ValidationFlagsEXT + struct ObjectTableDescriptorSetEntryNVX { - ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) - : sType( StructureType::eValidationFlagsEXT ) - , pNext( nullptr ) - , disabledValidationCheckCount( disabledValidationCheckCount_ ) - , pDisabledValidationChecks( pDisabledValidationChecks_ ) + ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), DescriptorSet descriptorSet_ = DescriptorSet() ) + : type( type_ ) + , flags( flags_ ) + , pipelineLayout( pipelineLayout_ ) + , descriptorSet( descriptorSet_ ) { } - ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) + ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); + memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); } - ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) + ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); + memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); return *this; } - ValidationFlagsEXT& setPNext( const void* pNext_ ) + ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ ) { - pNext = pNext_; + type = type_; return *this; } - ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ ) + ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) { - disabledValidationCheckCount = disabledValidationCheckCount_; + flags = flags_; return *this; } - ValidationFlagsEXT& setPDisabledValidationChecks( ValidationCheckEXT* pDisabledValidationChecks_ ) + ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) { - pDisabledValidationChecks = pDisabledValidationChecks_; + pipelineLayout = pipelineLayout_; return *this; } - operator const VkValidationFlagsEXT&() const + ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ ) { - return *reinterpret_cast(this); + descriptorSet = descriptorSet_; + return *this; } - bool operator==( ValidationFlagsEXT const& rhs ) const + operator const VkObjectTableDescriptorSetEntryNVX&() const { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) - && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); + return *reinterpret_cast(this); } - bool operator!=( ValidationFlagsEXT const& rhs ) const + bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const { - return !operator==( rhs ); + return ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( pipelineLayout == rhs.pipelineLayout ) + && ( descriptorSet == rhs.descriptorSet ); } - private: - StructureType sType; - - public: - const void* pNext; - uint32_t disabledValidationCheckCount; - ValidationCheckEXT* pDisabledValidationChecks; - }; - static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); + bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const + { + return !operator==( rhs ); + } - enum class IndirectCommandsLayoutUsageFlagBitsNVX - { - eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX, - eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX, - eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX, - eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + PipelineLayout pipelineLayout; + DescriptorSet descriptorSet; }; + static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" ); - using IndirectCommandsLayoutUsageFlagsNVX = Flags; - - VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 ) - { - return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits ) + struct ObjectTableVertexBufferEntryNVX { - return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) ); - } + ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer() ) + : type( type_ ) + , flags( flags_ ) + , buffer( buffer_ ) + { + } - template <> struct FlagTraits - { - enum + ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) { - allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) - }; - }; + memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); + } - enum class ObjectEntryUsageFlagBitsNVX - { - eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX, - eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX - }; + ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) + { + memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); + return *this; + } + ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) + { + type = type_; + return *this; + } - using ObjectEntryUsageFlagsNVX = Flags; + ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } - VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 ) - { - return ObjectEntryUsageFlagsNVX( bit0 ) | bit1; - } + ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } - VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits ) - { - return ~( ObjectEntryUsageFlagsNVX( bits ) ); - } + operator const VkObjectTableVertexBufferEntryNVX&() const + { + return *reinterpret_cast(this); + } - template <> struct FlagTraits - { - enum + bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const { - allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute) - }; - }; + return ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( buffer == rhs.buffer ); + } - enum class IndirectCommandsTokenTypeNVX - { - ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, - eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX, - eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX, - eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX, - ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX, - eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, - eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, - eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX + bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const + { + return !operator==( rhs ); + } + + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + Buffer buffer; }; + static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" ); - struct IndirectCommandsTokenNVX + struct ObjectTableIndexBufferEntryNVX { - IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0 ) - : tokenType( tokenType_ ) + ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer(), IndexType indexType_ = IndexType::eUint16 ) + : type( type_ ) + , flags( flags_ ) , buffer( buffer_ ) - , offset( offset_ ) + , indexType( indexType_ ) { } - IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) + ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); + memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); } - IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) + ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); + memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); return *this; } - IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) + ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) { - tokenType = tokenType_; + type = type_; return *this; } - IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ ) + ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + { + flags = flags_; + return *this; + } + + ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ ) { buffer = buffer_; return *this; } - IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ ) + ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ ) { - offset = offset_; + indexType = indexType_; return *this; } - operator const VkIndirectCommandsTokenNVX&() const + operator const VkObjectTableIndexBufferEntryNVX&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( IndirectCommandsTokenNVX const& rhs ) const + bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const { - return ( tokenType == rhs.tokenType ) + return ( type == rhs.type ) + && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) - && ( offset == rhs.offset ); + && ( indexType == rhs.indexType ); } - bool operator!=( IndirectCommandsTokenNVX const& rhs ) const + bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const { return !operator==( rhs ); } - IndirectCommandsTokenTypeNVX tokenType; + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; Buffer buffer; - DeviceSize offset; + IndexType indexType; }; - static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" ); - struct IndirectCommandsLayoutTokenNVX + struct ObjectTablePushConstantEntryNVX { - IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, uint32_t bindingUnit_ = 0, uint32_t dynamicCount_ = 0, uint32_t divisor_ = 0 ) - : tokenType( tokenType_ ) - , bindingUnit( bindingUnit_ ) - , dynamicCount( dynamicCount_ ) - , divisor( divisor_ ) + ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), ShaderStageFlags stageFlags_ = ShaderStageFlags() ) + : type( type_ ) + , flags( flags_ ) + , pipelineLayout( pipelineLayout_ ) + , stageFlags( stageFlags_ ) { } - IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) + ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); + memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); } - IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) + ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); + memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); return *this; } - IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) + ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ ) { - tokenType = tokenType_; + type = type_; return *this; } - IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ ) + ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) { - bindingUnit = bindingUnit_; + flags = flags_; return *this; } - IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ ) + ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) { - dynamicCount = dynamicCount_; + pipelineLayout = pipelineLayout_; return *this; } - IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ ) + ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ ) { - divisor = divisor_; + stageFlags = stageFlags_; return *this; } - operator const VkIndirectCommandsLayoutTokenNVX&() const + operator const VkObjectTablePushConstantEntryNVX&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const + bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const { - return ( tokenType == rhs.tokenType ) - && ( bindingUnit == rhs.bindingUnit ) - && ( dynamicCount == rhs.dynamicCount ) - && ( divisor == rhs.divisor ); + return ( type == rhs.type ) + && ( flags == rhs.flags ) + && ( pipelineLayout == rhs.pipelineLayout ) + && ( stageFlags == rhs.stageFlags ); } - bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const + bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const { return !operator==( rhs ); } - IndirectCommandsTokenTypeNVX tokenType; - uint32_t bindingUnit; - uint32_t dynamicCount; - uint32_t divisor; + ObjectEntryTypeNVX type; + ObjectEntryUsageFlagsNVX flags; + PipelineLayout pipelineLayout; + ShaderStageFlags stageFlags; }; - static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" ); - struct IndirectCommandsLayoutCreateInfoNVX + enum class DescriptorSetLayoutCreateFlagBits { - IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) - : sType( StructureType::eIndirectCommandsLayoutCreateInfoNVX ) + ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR + }; + + using DescriptorSetLayoutCreateFlags = Flags; + + VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 ) + { + return DescriptorSetLayoutCreateFlags( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits ) + { + return ~( DescriptorSetLayoutCreateFlags( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) + }; + }; + + struct DescriptorSetLayoutCreateInfo + { + DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr ) + : sType( StructureType::eDescriptorSetLayoutCreateInfo ) , pNext( nullptr ) - , pipelineBindPoint( pipelineBindPoint_ ) , flags( flags_ ) - , tokenCount( tokenCount_ ) - , pTokens( pTokens_ ) + , bindingCount( bindingCount_ ) + , pBindings( pBindings_ ) { } - IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) + DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); + } + + DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) + { + memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); + return *this; + } + DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ ) + { + flags = flags_; + return *this; + } + + DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ ) + { + bindingCount = bindingCount_; + return *this; + } + + DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ ) + { + pBindings = pBindings_; + return *this; + } + + operator const VkDescriptorSetLayoutCreateInfo&() const + { + return *reinterpret_cast(this); + } + + bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( bindingCount == rhs.bindingCount ) + && ( pBindings == rhs.pBindings ); + } + + bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const + { + return !operator==( rhs ); } - IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) + private: + StructureType sType; + + public: + const void* pNext; + DescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const DescriptorSetLayoutBinding* pBindings; + }; + static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" ); + + enum class ExternalMemoryHandleTypeFlagBitsKHR + { + eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, + eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR, + eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, + eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR + }; + + using ExternalMemoryHandleTypeFlagsKHR = Flags; + + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHR operator|( ExternalMemoryHandleTypeFlagBitsKHR bit0, ExternalMemoryHandleTypeFlagBitsKHR bit1 ) + { + return ExternalMemoryHandleTypeFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHR operator~( ExternalMemoryHandleTypeFlagBitsKHR bits ) + { + return ~( ExternalMemoryHandleTypeFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); - return *this; - } - IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ ) + allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) + }; + }; + + struct PhysicalDeviceExternalImageFormatInfoKHR + { + PhysicalDeviceExternalImageFormatInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::ePhysicalDeviceExternalImageFormatInfoKHR ) + , pNext( nullptr ) + , handleType( handleType_ ) { - pNext = pNext_; - return *this; } - IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) + PhysicalDeviceExternalImageFormatInfoKHR( VkPhysicalDeviceExternalImageFormatInfoKHR const & rhs ) { - pipelineBindPoint = pipelineBindPoint_; - return *this; + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) ); } - IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ ) + PhysicalDeviceExternalImageFormatInfoKHR& operator=( VkPhysicalDeviceExternalImageFormatInfoKHR const & rhs ) { - flags = flags_; + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) ); return *this; } - - IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ ) + PhysicalDeviceExternalImageFormatInfoKHR& setPNext( const void* pNext_ ) { - tokenCount = tokenCount_; + pNext = pNext_; return *this; } - IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ ) + PhysicalDeviceExternalImageFormatInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { - pTokens = pTokens_; + handleType = handleType_; return *this; } - operator const VkIndirectCommandsLayoutCreateInfoNVX&() const + operator const VkPhysicalDeviceExternalImageFormatInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const + bool operator==( PhysicalDeviceExternalImageFormatInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( pipelineBindPoint == rhs.pipelineBindPoint ) - && ( flags == rhs.flags ) - && ( tokenCount == rhs.tokenCount ) - && ( pTokens == rhs.pTokens ); + && ( handleType == rhs.handleType ); } - bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const + bool operator!=( PhysicalDeviceExternalImageFormatInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19252,130 +20532,129 @@ namespace vk public: const void* pNext; - PipelineBindPoint pipelineBindPoint; - IndirectCommandsLayoutUsageFlagsNVX flags; - uint32_t tokenCount; - const IndirectCommandsLayoutTokenNVX* pTokens; - }; - static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" ); - - enum class ObjectEntryTypeNVX - { - eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, - ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX, - eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX, - eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX, - ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX + ExternalMemoryHandleTypeFlagBitsKHR handleType; }; + static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHR ), "struct and wrapper have different size!" ); - struct ObjectTableCreateInfoNVX + struct PhysicalDeviceExternalBufferInfoKHR { - ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, const uint32_t* pObjectEntryCounts_ = nullptr, const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, uint32_t maxUniformBuffersPerDescriptor_ = 0, uint32_t maxStorageBuffersPerDescriptor_ = 0, uint32_t maxStorageImagesPerDescriptor_ = 0, uint32_t maxSampledImagesPerDescriptor_ = 0, uint32_t maxPipelineLayouts_ = 0 ) - : sType( StructureType::eObjectTableCreateInfoNVX ) + PhysicalDeviceExternalBufferInfoKHR( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::ePhysicalDeviceExternalBufferInfoKHR ) , pNext( nullptr ) - , objectCount( objectCount_ ) - , pObjectEntryTypes( pObjectEntryTypes_ ) - , pObjectEntryCounts( pObjectEntryCounts_ ) - , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) - , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ ) - , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ ) - , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ ) - , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ ) - , maxPipelineLayouts( maxPipelineLayouts_ ) + , flags( flags_ ) + , usage( usage_ ) + , handleType( handleType_ ) { } - ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) + PhysicalDeviceExternalBufferInfoKHR( VkPhysicalDeviceExternalBufferInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHR ) ); } - ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) + PhysicalDeviceExternalBufferInfoKHR& operator=( VkPhysicalDeviceExternalBufferInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHR ) ); return *this; } - ObjectTableCreateInfoNVX& setPNext( const void* pNext_ ) + PhysicalDeviceExternalBufferInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ ) + PhysicalDeviceExternalBufferInfoKHR& setFlags( BufferCreateFlags flags_ ) { - objectCount = objectCount_; + flags = flags_; return *this; } - ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ ) + PhysicalDeviceExternalBufferInfoKHR& setUsage( BufferUsageFlags usage_ ) { - pObjectEntryTypes = pObjectEntryTypes_; + usage = usage_; return *this; } - ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ ) + PhysicalDeviceExternalBufferInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { - pObjectEntryCounts = pObjectEntryCounts_; + handleType = handleType_; return *this; } - ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ ) + operator const VkPhysicalDeviceExternalBufferInfoKHR&() const { - pObjectEntryUsageFlags = pObjectEntryUsageFlags_; - return *this; + return *reinterpret_cast(this); } - ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ ) + bool operator==( PhysicalDeviceExternalBufferInfoKHR const& rhs ) const { - maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_; - return *this; + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( usage == rhs.usage ) + && ( handleType == rhs.handleType ); } - ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ ) + bool operator!=( PhysicalDeviceExternalBufferInfoKHR const& rhs ) const { - maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_; - return *this; + return !operator==( rhs ); } - ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ ) + private: + StructureType sType; + + public: + const void* pNext; + BufferCreateFlags flags; + BufferUsageFlags usage; + ExternalMemoryHandleTypeFlagBitsKHR handleType; + }; + static_assert( sizeof( PhysicalDeviceExternalBufferInfoKHR ) == sizeof( VkPhysicalDeviceExternalBufferInfoKHR ), "struct and wrapper have different size!" ); + + struct ExternalMemoryImageCreateInfoKHR + { + ExternalMemoryImageCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) + : sType( StructureType::eExternalMemoryImageCreateInfoKHR ) + , pNext( nullptr ) + , handleTypes( handleTypes_ ) { - maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_; - return *this; } - ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ ) + ExternalMemoryImageCreateInfoKHR( VkExternalMemoryImageCreateInfoKHR const & rhs ) { - maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_; + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHR ) ); + } + + ExternalMemoryImageCreateInfoKHR& operator=( VkExternalMemoryImageCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHR ) ); + return *this; + } + ExternalMemoryImageCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; return *this; } - ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ ) + ExternalMemoryImageCreateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ ) { - maxPipelineLayouts = maxPipelineLayouts_; + handleTypes = handleTypes_; return *this; } - operator const VkObjectTableCreateInfoNVX&() const + operator const VkExternalMemoryImageCreateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ObjectTableCreateInfoNVX const& rhs ) const + bool operator==( ExternalMemoryImageCreateInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( objectCount == rhs.objectCount ) - && ( pObjectEntryTypes == rhs.pObjectEntryTypes ) - && ( pObjectEntryCounts == rhs.pObjectEntryCounts ) - && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags ) - && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor ) - && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor ) - && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor ) - && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor ) - && ( maxPipelineLayouts == rhs.maxPipelineLayouts ); + && ( handleTypes == rhs.handleTypes ); } - bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const + bool operator!=( ExternalMemoryImageCreateInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19385,481 +20664,496 @@ namespace vk public: const void* pNext; - uint32_t objectCount; - const ObjectEntryTypeNVX* pObjectEntryTypes; - const uint32_t* pObjectEntryCounts; - const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; - uint32_t maxUniformBuffersPerDescriptor; - uint32_t maxStorageBuffersPerDescriptor; - uint32_t maxStorageImagesPerDescriptor; - uint32_t maxSampledImagesPerDescriptor; - uint32_t maxPipelineLayouts; + ExternalMemoryHandleTypeFlagsKHR handleTypes; }; - static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExternalMemoryImageCreateInfoKHR ) == sizeof( VkExternalMemoryImageCreateInfoKHR ), "struct and wrapper have different size!" ); - struct ObjectTableEntryNVX + struct ExternalMemoryBufferCreateInfoKHR { - ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() ) - : type( type_ ) - , flags( flags_ ) + ExternalMemoryBufferCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) + : sType( StructureType::eExternalMemoryBufferCreateInfoKHR ) + , pNext( nullptr ) + , handleTypes( handleTypes_ ) { } - ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) + ExternalMemoryBufferCreateInfoKHR( VkExternalMemoryBufferCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); + memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHR ) ); } - ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) + ExternalMemoryBufferCreateInfoKHR& operator=( VkExternalMemoryBufferCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); + memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHR ) ); return *this; } - ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ ) + ExternalMemoryBufferCreateInfoKHR& setPNext( const void* pNext_ ) { - type = type_; + pNext = pNext_; return *this; } - ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + ExternalMemoryBufferCreateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ ) { - flags = flags_; + handleTypes = handleTypes_; return *this; } - operator const VkObjectTableEntryNVX&() const + operator const VkExternalMemoryBufferCreateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ObjectTableEntryNVX const& rhs ) const + bool operator==( ExternalMemoryBufferCreateInfoKHR const& rhs ) const { - return ( type == rhs.type ) - && ( flags == rhs.flags ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); } - bool operator!=( ObjectTableEntryNVX const& rhs ) const + bool operator!=( ExternalMemoryBufferCreateInfoKHR const& rhs ) const { return !operator==( rhs ); } - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; + private: + StructureType sType; + + public: + const void* pNext; + ExternalMemoryHandleTypeFlagsKHR handleTypes; }; - static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExternalMemoryBufferCreateInfoKHR ) == sizeof( VkExternalMemoryBufferCreateInfoKHR ), "struct and wrapper have different size!" ); - struct ObjectTablePipelineEntryNVX + struct ExportMemoryAllocateInfoKHR { - ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Pipeline pipeline_ = Pipeline() ) - : type( type_ ) - , flags( flags_ ) - , pipeline( pipeline_ ) + ExportMemoryAllocateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) + : sType( StructureType::eExportMemoryAllocateInfoKHR ) + , pNext( nullptr ) + , handleTypes( handleTypes_ ) { } - ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) + ExportMemoryAllocateInfoKHR( VkExportMemoryAllocateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHR ) ); } - ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); - return *this; - } - ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ ) + ExportMemoryAllocateInfoKHR& operator=( VkExportMemoryAllocateInfoKHR const & rhs ) { - type = type_; + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHR ) ); return *this; } - - ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + ExportMemoryAllocateInfoKHR& setPNext( const void* pNext_ ) { - flags = flags_; + pNext = pNext_; return *this; } - ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ ) + ExportMemoryAllocateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ ) { - pipeline = pipeline_; + handleTypes = handleTypes_; return *this; } - operator const VkObjectTablePipelineEntryNVX&() const + operator const VkExportMemoryAllocateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const + bool operator==( ExportMemoryAllocateInfoKHR const& rhs ) const { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( pipeline == rhs.pipeline ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); } - bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const + bool operator!=( ExportMemoryAllocateInfoKHR const& rhs ) const { return !operator==( rhs ); } - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - Pipeline pipeline; + private: + StructureType sType; + + public: + const void* pNext; + ExternalMemoryHandleTypeFlagsKHR handleTypes; }; - static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExportMemoryAllocateInfoKHR ) == sizeof( VkExportMemoryAllocateInfoKHR ), "struct and wrapper have different size!" ); - struct ObjectTableDescriptorSetEntryNVX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportMemoryWin32HandleInfoKHR { - ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), DescriptorSet descriptorSet_ = DescriptorSet() ) - : type( type_ ) - , flags( flags_ ) - , pipelineLayout( pipelineLayout_ ) - , descriptorSet( descriptorSet_ ) + ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eImportMemoryWin32HandleInfoKHR ) + , pNext( nullptr ) + , handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) { } - ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) + ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); } - ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) + ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); return *this; } - ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ ) + ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) { - type = type_; + pNext = pNext_; return *this; } - ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { - flags = flags_; + handleType = handleType_; return *this; } - ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) + ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ ) { - pipelineLayout = pipelineLayout_; + handle = handle_; return *this; } - ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ ) + ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) { - descriptorSet = descriptorSet_; + name = name_; return *this; } - operator const VkObjectTableDescriptorSetEntryNVX&() const + operator const VkImportMemoryWin32HandleInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - - bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( pipelineLayout == rhs.pipelineLayout ) - && ( descriptorSet == rhs.descriptorSet ); + + bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ) + && ( handle == rhs.handle ) + && ( name == rhs.name ); } - bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const + bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - PipelineLayout pipelineLayout; - DescriptorSet descriptorSet; + private: + StructureType sType; + + public: + const void* pNext; + ExternalMemoryHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; }; - static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - struct ObjectTableVertexBufferEntryNVX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct MemoryGetWin32HandleInfoKHR { - ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer() ) - : type( type_ ) - , flags( flags_ ) - , buffer( buffer_ ) + MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eMemoryGetWin32HandleInfoKHR ) + , pNext( nullptr ) + , memory( memory_ ) + , handleType( handleType_ ) { } - ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) + MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); + memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); } - ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) + MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); + memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); return *this; } - ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) + MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) { - type = type_; + pNext = pNext_; return *this; } - ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ ) { - flags = flags_; + memory = memory_; return *this; } - ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ ) + MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { - buffer = buffer_; + handleType = handleType_; return *this; } - operator const VkObjectTableVertexBufferEntryNVX&() const + operator const VkMemoryGetWin32HandleInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const + bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( buffer == rhs.buffer ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memory == rhs.memory ) + && ( handleType == rhs.handleType ); } - bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const + bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - Buffer buffer; + private: + StructureType sType; + + public: + const void* pNext; + DeviceMemory memory; + ExternalMemoryHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - struct ObjectTableIndexBufferEntryNVX + struct ImportMemoryFdInfoKHR { - ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer(), IndexType indexType_ = IndexType::eUint16 ) - : type( type_ ) - , flags( flags_ ) - , buffer( buffer_ ) - , indexType( indexType_ ) + ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) + : sType( StructureType::eImportMemoryFdInfoKHR ) + , pNext( nullptr ) + , handleType( handleType_ ) + , fd( fd_ ) { } - ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) + ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); + memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); } - ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); - return *this; - } - ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) + ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) { - type = type_; + memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); return *this; } - - ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + ImportMemoryFdInfoKHR& setPNext( const void* pNext_ ) { - flags = flags_; + pNext = pNext_; return *this; } - ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ ) + ImportMemoryFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { - buffer = buffer_; + handleType = handleType_; return *this; } - ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ ) + ImportMemoryFdInfoKHR& setFd( int fd_ ) { - indexType = indexType_; + fd = fd_; return *this; } - operator const VkObjectTableIndexBufferEntryNVX&() const + operator const VkImportMemoryFdInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const + bool operator==( ImportMemoryFdInfoKHR const& rhs ) const { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( buffer == rhs.buffer ) - && ( indexType == rhs.indexType ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ) + && ( fd == rhs.fd ); } - bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const + bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const { return !operator==( rhs ); } - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - Buffer buffer; - IndexType indexType; + private: + StructureType sType; + + public: + const void* pNext; + ExternalMemoryHandleTypeFlagBitsKHR handleType; + int fd; }; - static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" ); - struct ObjectTablePushConstantEntryNVX + struct MemoryGetFdInfoKHR { - ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), ShaderStageFlags stageFlags_ = ShaderStageFlags() ) - : type( type_ ) - , flags( flags_ ) - , pipelineLayout( pipelineLayout_ ) - , stageFlags( stageFlags_ ) + MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eMemoryGetFdInfoKHR ) + , pNext( nullptr ) + , memory( memory_ ) + , handleType( handleType_ ) { } - ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) + MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); + memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); } - ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); - return *this; - } - ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ ) + MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) { - type = type_; + memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); return *this; } - - ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) + MemoryGetFdInfoKHR& setPNext( const void* pNext_ ) { - flags = flags_; + pNext = pNext_; return *this; } - ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) + MemoryGetFdInfoKHR& setMemory( DeviceMemory memory_ ) { - pipelineLayout = pipelineLayout_; + memory = memory_; return *this; } - ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ ) + MemoryGetFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { - stageFlags = stageFlags_; + handleType = handleType_; return *this; } - operator const VkObjectTablePushConstantEntryNVX&() const + operator const VkMemoryGetFdInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const + bool operator==( MemoryGetFdInfoKHR const& rhs ) const { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( pipelineLayout == rhs.pipelineLayout ) - && ( stageFlags == rhs.stageFlags ); + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memory == rhs.memory ) + && ( handleType == rhs.handleType ); } - bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const + bool operator!=( MemoryGetFdInfoKHR const& rhs ) const { return !operator==( rhs ); } - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - PipelineLayout pipelineLayout; - ShaderStageFlags stageFlags; + private: + StructureType sType; + + public: + const void* pNext; + DeviceMemory memory; + ExternalMemoryHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" ); + static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); - enum class DescriptorSetLayoutCreateFlagBits + enum class ExternalMemoryFeatureFlagBitsKHR { - ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR + eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR, + eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR, + eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR }; - using DescriptorSetLayoutCreateFlags = Flags; + using ExternalMemoryFeatureFlagsKHR = Flags; - VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 ) + VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHR operator|( ExternalMemoryFeatureFlagBitsKHR bit0, ExternalMemoryFeatureFlagBitsKHR bit1 ) { - return DescriptorSetLayoutCreateFlags( bit0 ) | bit1; + return ExternalMemoryFeatureFlagsKHR( bit0 ) | bit1; } - VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits ) + VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHR operator~( ExternalMemoryFeatureFlagBitsKHR bits ) { - return ~( DescriptorSetLayoutCreateFlags( bits ) ); + return ~( ExternalMemoryFeatureFlagsKHR( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) + allFlags = VkFlags(ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsKHR::eImportable) }; }; - struct DescriptorSetLayoutCreateInfo + struct ExternalMemoryPropertiesKHR { - DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr ) - : sType( StructureType::eDescriptorSetLayoutCreateInfo ) - , pNext( nullptr ) - , flags( flags_ ) - , bindingCount( bindingCount_ ) - , pBindings( pBindings_ ) + operator const VkExternalMemoryPropertiesKHR&() const { + return *reinterpret_cast(this); } - DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) + bool operator==( ExternalMemoryPropertiesKHR const& rhs ) const { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); + return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) + && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) + && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); } - DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); - return *this; - } - DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ ) + bool operator!=( ExternalMemoryPropertiesKHR const& rhs ) const { - pNext = pNext_; - return *this; + return !operator==( rhs ); } - DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ ) + ExternalMemoryFeatureFlagsKHR externalMemoryFeatures; + ExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes; + ExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes; + }; + static_assert( sizeof( ExternalMemoryPropertiesKHR ) == sizeof( VkExternalMemoryPropertiesKHR ), "struct and wrapper have different size!" ); + + struct ExternalImageFormatPropertiesKHR + { + operator const VkExternalImageFormatPropertiesKHR&() const { - flags = flags_; - return *this; + return *reinterpret_cast(this); } - DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ ) + bool operator==( ExternalImageFormatPropertiesKHR const& rhs ) const { - bindingCount = bindingCount_; - return *this; + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( externalMemoryProperties == rhs.externalMemoryProperties ); } - DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ ) + bool operator!=( ExternalImageFormatPropertiesKHR const& rhs ) const { - pBindings = pBindings_; - return *this; + return !operator==( rhs ); } - operator const VkDescriptorSetLayoutCreateInfo&() const + private: + StructureType sType; + + public: + void* pNext; + ExternalMemoryPropertiesKHR externalMemoryProperties; + }; + static_assert( sizeof( ExternalImageFormatPropertiesKHR ) == sizeof( VkExternalImageFormatPropertiesKHR ), "struct and wrapper have different size!" ); + + struct ExternalBufferPropertiesKHR + { + operator const VkExternalBufferPropertiesKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const + bool operator==( ExternalBufferPropertiesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( bindingCount == rhs.bindingCount ) - && ( pBindings == rhs.pBindings ); + && ( externalMemoryProperties == rhs.externalMemoryProperties ); } - bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const + bool operator!=( ExternalBufferPropertiesKHR const& rhs ) const { return !operator==( rhs ); } @@ -19868,88 +21162,84 @@ namespace vk StructureType sType; public: - const void* pNext; - DescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const DescriptorSetLayoutBinding* pBindings; + void* pNext; + ExternalMemoryPropertiesKHR externalMemoryProperties; }; - static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExternalBufferPropertiesKHR ) == sizeof( VkExternalBufferPropertiesKHR ), "struct and wrapper have different size!" ); - enum class ExternalMemoryHandleTypeFlagBitsKHX + enum class ExternalSemaphoreHandleTypeFlagBitsKHR { - eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX, - eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX, - eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX, - eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX, - eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX, - eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX, - eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX + eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, + eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR }; - using ExternalMemoryHandleTypeFlagsKHX = Flags; + using ExternalSemaphoreHandleTypeFlagsKHR = Flags; - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHX operator|( ExternalMemoryHandleTypeFlagBitsKHX bit0, ExternalMemoryHandleTypeFlagBitsKHX bit1 ) + VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHR operator|( ExternalSemaphoreHandleTypeFlagBitsKHR bit0, ExternalSemaphoreHandleTypeFlagBitsKHR bit1 ) { - return ExternalMemoryHandleTypeFlagsKHX( bit0 ) | bit1; + return ExternalSemaphoreHandleTypeFlagsKHR( bit0 ) | bit1; } - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHX operator~( ExternalMemoryHandleTypeFlagBitsKHX bits ) + VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHR operator~( ExternalSemaphoreHandleTypeFlagBitsKHR bits ) { - return ~( ExternalMemoryHandleTypeFlagsKHX( bits ) ); + return ~( ExternalSemaphoreHandleTypeFlagsKHR( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Resource) + allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd) }; }; - struct PhysicalDeviceExternalImageFormatInfoKHX + struct PhysicalDeviceExternalSemaphoreInfoKHR { - PhysicalDeviceExternalImageFormatInfoKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalImageFormatInfoKHX ) + PhysicalDeviceExternalSemaphoreInfoKHR( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR ) , pNext( nullptr ) , handleType( handleType_ ) { } - PhysicalDeviceExternalImageFormatInfoKHX( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs ) + PhysicalDeviceExternalSemaphoreInfoKHR( VkPhysicalDeviceExternalSemaphoreInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHX ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) ); } - PhysicalDeviceExternalImageFormatInfoKHX& operator=( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs ) + PhysicalDeviceExternalSemaphoreInfoKHR& operator=( VkPhysicalDeviceExternalSemaphoreInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHX ) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) ); return *this; } - PhysicalDeviceExternalImageFormatInfoKHX& setPNext( const void* pNext_ ) + PhysicalDeviceExternalSemaphoreInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceExternalImageFormatInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ ) + PhysicalDeviceExternalSemaphoreInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - operator const VkPhysicalDeviceExternalImageFormatInfoKHX&() const + operator const VkPhysicalDeviceExternalSemaphoreInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceExternalImageFormatInfoKHX const& rhs ) const + bool operator==( PhysicalDeviceExternalSemaphoreInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); } - bool operator!=( PhysicalDeviceExternalImageFormatInfoKHX const& rhs ) const + bool operator!=( PhysicalDeviceExternalSemaphoreInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19959,70 +21249,54 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagBitsKHX handleType; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHX ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceExternalBufferInfoKHX + struct ExportSemaphoreCreateInfoKHR { - PhysicalDeviceExternalBufferInfoKHX( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalBufferInfoKHX ) + ExportSemaphoreCreateInfoKHR( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHR() ) + : sType( StructureType::eExportSemaphoreCreateInfoKHR ) , pNext( nullptr ) - , flags( flags_ ) - , usage( usage_ ) - , handleType( handleType_ ) + , handleTypes( handleTypes_ ) { } - PhysicalDeviceExternalBufferInfoKHX( VkPhysicalDeviceExternalBufferInfoKHX const & rhs ) + ExportSemaphoreCreateInfoKHR( VkExportSemaphoreCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHX ) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHR ) ); } - PhysicalDeviceExternalBufferInfoKHX& operator=( VkPhysicalDeviceExternalBufferInfoKHX const & rhs ) + ExportSemaphoreCreateInfoKHR& operator=( VkExportSemaphoreCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHX ) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHR ) ); return *this; } - PhysicalDeviceExternalBufferInfoKHX& setPNext( const void* pNext_ ) + ExportSemaphoreCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceExternalBufferInfoKHX& setFlags( BufferCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PhysicalDeviceExternalBufferInfoKHX& setUsage( BufferUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - PhysicalDeviceExternalBufferInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ ) + ExportSemaphoreCreateInfoKHR& setHandleTypes( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ ) { - handleType = handleType_; + handleTypes = handleTypes_; return *this; } - operator const VkPhysicalDeviceExternalBufferInfoKHX&() const + operator const VkExportSemaphoreCreateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceExternalBufferInfoKHX const& rhs ) const + bool operator==( ExportSemaphoreCreateInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( usage == rhs.usage ) - && ( handleType == rhs.handleType ); + && ( handleTypes == rhs.handleTypes ); } - bool operator!=( PhysicalDeviceExternalBufferInfoKHX const& rhs ) const + bool operator!=( ExportSemaphoreCreateInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20032,56 +21306,63 @@ namespace vk public: const void* pNext; - BufferCreateFlags flags; - BufferUsageFlags usage; - ExternalMemoryHandleTypeFlagBitsKHX handleType; + ExternalSemaphoreHandleTypeFlagsKHR handleTypes; }; - static_assert( sizeof( PhysicalDeviceExternalBufferInfoKHX ) == sizeof( VkPhysicalDeviceExternalBufferInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExportSemaphoreCreateInfoKHR ) == sizeof( VkExportSemaphoreCreateInfoKHR ), "struct and wrapper have different size!" ); - struct ExternalMemoryImageCreateInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SemaphoreGetWin32HandleInfoKHR { - ExternalMemoryImageCreateInfoKHX( ExternalMemoryHandleTypeFlagsKHX handleTypes_ = ExternalMemoryHandleTypeFlagsKHX() ) - : sType( StructureType::eExternalMemoryImageCreateInfoKHX ) + SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eSemaphoreGetWin32HandleInfoKHR ) , pNext( nullptr ) - , handleTypes( handleTypes_ ) + , semaphore( semaphore_ ) + , handleType( handleType_ ) { } - ExternalMemoryImageCreateInfoKHX( VkExternalMemoryImageCreateInfoKHX const & rhs ) + SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHX ) ); + memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); } - ExternalMemoryImageCreateInfoKHX& operator=( VkExternalMemoryImageCreateInfoKHX const & rhs ) + SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHX ) ); + memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); return *this; } - ExternalMemoryImageCreateInfoKHX& setPNext( const void* pNext_ ) + SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExternalMemoryImageCreateInfoKHX& setHandleTypes( ExternalMemoryHandleTypeFlagsKHX handleTypes_ ) + SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) { - handleTypes = handleTypes_; + semaphore = semaphore_; + return *this; + } + + SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; return *this; } - operator const VkExternalMemoryImageCreateInfoKHX&() const + operator const VkSemaphoreGetWin32HandleInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalMemoryImageCreateInfoKHX const& rhs ) const + bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); + && ( semaphore == rhs.semaphore ) + && ( handleType == rhs.handleType ); } - bool operator!=( ExternalMemoryImageCreateInfoKHX const& rhs ) const + bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20091,54 +21372,64 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagsKHX handleTypes; + Semaphore semaphore; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( ExternalMemoryImageCreateInfoKHX ) == sizeof( VkExternalMemoryImageCreateInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - struct ExternalMemoryBufferCreateInfoKHX + struct SemaphoreGetFdInfoKHR { - ExternalMemoryBufferCreateInfoKHX( ExternalMemoryHandleTypeFlagsKHX handleTypes_ = ExternalMemoryHandleTypeFlagsKHX() ) - : sType( StructureType::eExternalMemoryBufferCreateInfoKHX ) + SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eSemaphoreGetFdInfoKHR ) , pNext( nullptr ) - , handleTypes( handleTypes_ ) + , semaphore( semaphore_ ) + , handleType( handleType_ ) { } - ExternalMemoryBufferCreateInfoKHX( VkExternalMemoryBufferCreateInfoKHX const & rhs ) + SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHX ) ); + memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); } - ExternalMemoryBufferCreateInfoKHX& operator=( VkExternalMemoryBufferCreateInfoKHX const & rhs ) + SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHX ) ); + memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); return *this; } - ExternalMemoryBufferCreateInfoKHX& setPNext( const void* pNext_ ) + SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExternalMemoryBufferCreateInfoKHX& setHandleTypes( ExternalMemoryHandleTypeFlagsKHX handleTypes_ ) + SemaphoreGetFdInfoKHR& setSemaphore( Semaphore semaphore_ ) { - handleTypes = handleTypes_; + semaphore = semaphore_; + return *this; + } + + SemaphoreGetFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; return *this; } - operator const VkExternalMemoryBufferCreateInfoKHX&() const + operator const VkSemaphoreGetFdInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalMemoryBufferCreateInfoKHX const& rhs ) const + bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); + && ( semaphore == rhs.semaphore ) + && ( handleType == rhs.handleType ); } - bool operator!=( ExternalMemoryBufferCreateInfoKHX const& rhs ) const + bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20148,54 +21439,54 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagsKHX handleTypes; + Semaphore semaphore; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( ExternalMemoryBufferCreateInfoKHX ) == sizeof( VkExternalMemoryBufferCreateInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" ); - struct ExportMemoryAllocateInfoKHX + enum class ExternalSemaphoreFeatureFlagBitsKHR { - ExportMemoryAllocateInfoKHX( ExternalMemoryHandleTypeFlagsKHX handleTypes_ = ExternalMemoryHandleTypeFlagsKHX() ) - : sType( StructureType::eExportMemoryAllocateInfoKHX ) - , pNext( nullptr ) - , handleTypes( handleTypes_ ) - { - } + eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR, + eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR + }; - ExportMemoryAllocateInfoKHX( VkExportMemoryAllocateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHX ) ); - } + using ExternalSemaphoreFeatureFlagsKHR = Flags; - ExportMemoryAllocateInfoKHX& operator=( VkExportMemoryAllocateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHX ) ); - return *this; - } - ExportMemoryAllocateInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } + VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHR operator|( ExternalSemaphoreFeatureFlagBitsKHR bit0, ExternalSemaphoreFeatureFlagBitsKHR bit1 ) + { + return ExternalSemaphoreFeatureFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHR operator~( ExternalSemaphoreFeatureFlagBitsKHR bits ) + { + return ~( ExternalSemaphoreFeatureFlagsKHR( bits ) ); + } - ExportMemoryAllocateInfoKHX& setHandleTypes( ExternalMemoryHandleTypeFlagsKHX handleTypes_ ) + template <> struct FlagTraits + { + enum { - handleTypes = handleTypes_; - return *this; - } + allFlags = VkFlags(ExternalSemaphoreFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBitsKHR::eImportable) + }; + }; - operator const VkExportMemoryAllocateInfoKHX&() const + struct ExternalSemaphorePropertiesKHR + { + operator const VkExternalSemaphorePropertiesKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExportMemoryAllocateInfoKHX const& rhs ) const + bool operator==( ExternalSemaphorePropertiesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); + && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) + && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) + && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); } - bool operator!=( ExportMemoryAllocateInfoKHX const& rhs ) const + bool operator!=( ExternalSemaphorePropertiesKHR const& rhs ) const { return !operator==( rhs ); } @@ -20204,64 +21495,115 @@ namespace vk StructureType sType; public: - const void* pNext; - ExternalMemoryHandleTypeFlagsKHX handleTypes; + void* pNext; + ExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes; + ExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes; + ExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures; + }; + static_assert( sizeof( ExternalSemaphorePropertiesKHR ) == sizeof( VkExternalSemaphorePropertiesKHR ), "struct and wrapper have different size!" ); + + enum class SemaphoreImportFlagBitsKHR + { + eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR + }; + + using SemaphoreImportFlagsKHR = Flags; + + VULKAN_HPP_INLINE SemaphoreImportFlagsKHR operator|( SemaphoreImportFlagBitsKHR bit0, SemaphoreImportFlagBitsKHR bit1 ) + { + return SemaphoreImportFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SemaphoreImportFlagsKHR operator~( SemaphoreImportFlagBitsKHR bits ) + { + return ~( SemaphoreImportFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SemaphoreImportFlagBitsKHR::eTemporary) + }; }; - static_assert( sizeof( ExportMemoryAllocateInfoKHX ) == sizeof( VkExportMemoryAllocateInfoKHX ), "struct and wrapper have different size!" ); -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct ImportMemoryWin32HandleInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportSemaphoreWin32HandleInfoKHR { - ImportMemoryWin32HandleInfoKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd, HANDLE handle_ = 0 ) - : sType( StructureType::eImportMemoryWin32HandleInfoKHX ) + ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eImportSemaphoreWin32HandleInfoKHR ) , pNext( nullptr ) + , semaphore( semaphore_ ) + , flags( flags_ ) , handleType( handleType_ ) , handle( handle_ ) + , name( name_ ) { } - ImportMemoryWin32HandleInfoKHX( VkImportMemoryWin32HandleInfoKHX const & rhs ) + ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHX ) ); + memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); } - ImportMemoryWin32HandleInfoKHX& operator=( VkImportMemoryWin32HandleInfoKHX const & rhs ) + ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHX ) ); + memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); return *this; } - ImportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ ) + ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImportMemoryWin32HandleInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ ) + ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) + { + semaphore = semaphore_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - ImportMemoryWin32HandleInfoKHX& setHandle( HANDLE handle_ ) + ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ ) { handle = handle_; return *this; } - operator const VkImportMemoryWin32HandleInfoKHX&() const + ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkImportSemaphoreWin32HandleInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImportMemoryWin32HandleInfoKHX const& rhs ) const + bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) + && ( semaphore == rhs.semaphore ) + && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ); + && ( handle == rhs.handle ) + && ( name == rhs.name ); } - bool operator!=( ImportMemoryWin32HandleInfoKHX const& rhs ) const + bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20271,64 +21613,83 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagBitsKHX handleType; + Semaphore semaphore; + SemaphoreImportFlagsKHR flags; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; HANDLE handle; + LPCWSTR name; }; - static_assert( sizeof( ImportMemoryWin32HandleInfoKHX ) == sizeof( VkImportMemoryWin32HandleInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - struct ImportMemoryFdInfoKHX + struct ImportSemaphoreFdInfoKHR { - ImportMemoryFdInfoKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd, int fd_ = 0 ) - : sType( StructureType::eImportMemoryFdInfoKHX ) + ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) + : sType( StructureType::eImportSemaphoreFdInfoKHR ) , pNext( nullptr ) + , semaphore( semaphore_ ) + , flags( flags_ ) , handleType( handleType_ ) , fd( fd_ ) { } - ImportMemoryFdInfoKHX( VkImportMemoryFdInfoKHX const & rhs ) + ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHX ) ); + memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); } - ImportMemoryFdInfoKHX& operator=( VkImportMemoryFdInfoKHX const & rhs ) + ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHX ) ); + memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); return *this; } - ImportMemoryFdInfoKHX& setPNext( const void* pNext_ ) + ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImportMemoryFdInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ ) + ImportSemaphoreFdInfoKHR& setSemaphore( Semaphore semaphore_ ) + { + semaphore = semaphore_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setFlags( SemaphoreImportFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - ImportMemoryFdInfoKHX& setFd( int fd_ ) + ImportSemaphoreFdInfoKHR& setFd( int fd_ ) { fd = fd_; return *this; } - operator const VkImportMemoryFdInfoKHX&() const + operator const VkImportSemaphoreFdInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImportMemoryFdInfoKHX const& rhs ) const + bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) + && ( semaphore == rhs.semaphore ) + && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); } - bool operator!=( ImportMemoryFdInfoKHX const& rhs ) const + bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20338,78 +21699,85 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagBitsKHX handleType; + Semaphore semaphore; + SemaphoreImportFlagsKHR flags; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; int fd; }; - static_assert( sizeof( ImportMemoryFdInfoKHX ) == sizeof( VkImportMemoryFdInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" ); - enum class ExternalMemoryFeatureFlagBitsKHX + enum class ExternalFenceHandleTypeFlagBitsKHR { - eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX, - eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX, - eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX + eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR }; - using ExternalMemoryFeatureFlagsKHX = Flags; + using ExternalFenceHandleTypeFlagsKHR = Flags; - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHX operator|( ExternalMemoryFeatureFlagBitsKHX bit0, ExternalMemoryFeatureFlagBitsKHX bit1 ) + VULKAN_HPP_INLINE ExternalFenceHandleTypeFlagsKHR operator|( ExternalFenceHandleTypeFlagBitsKHR bit0, ExternalFenceHandleTypeFlagBitsKHR bit1 ) { - return ExternalMemoryFeatureFlagsKHX( bit0 ) | bit1; + return ExternalFenceHandleTypeFlagsKHR( bit0 ) | bit1; } - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHX operator~( ExternalMemoryFeatureFlagBitsKHX bits ) + VULKAN_HPP_INLINE ExternalFenceHandleTypeFlagsKHR operator~( ExternalFenceHandleTypeFlagBitsKHR bits ) { - return ~( ExternalMemoryFeatureFlagsKHX( bits ) ); + return ~( ExternalFenceHandleTypeFlagsKHR( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(ExternalMemoryFeatureFlagBitsKHX::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsKHX::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsKHX::eImportable) + allFlags = VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eSyncFd) }; }; - struct ExternalMemoryPropertiesKHX + struct PhysicalDeviceExternalFenceInfoKHR { - operator const VkExternalMemoryPropertiesKHX&() const + PhysicalDeviceExternalFenceInfoKHR( ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::ePhysicalDeviceExternalFenceInfoKHR ) + , pNext( nullptr ) + , handleType( handleType_ ) { - return *reinterpret_cast(this); } - bool operator==( ExternalMemoryPropertiesKHX const& rhs ) const + PhysicalDeviceExternalFenceInfoKHR( VkPhysicalDeviceExternalFenceInfoKHR const & rhs ) { - return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfoKHR ) ); } - bool operator!=( ExternalMemoryPropertiesKHX const& rhs ) const + PhysicalDeviceExternalFenceInfoKHR& operator=( VkPhysicalDeviceExternalFenceInfoKHR const & rhs ) { - return !operator==( rhs ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfoKHR ) ); + return *this; + } + PhysicalDeviceExternalFenceInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; } - ExternalMemoryFeatureFlagsKHX externalMemoryFeatures; - ExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes; - ExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes; - }; - static_assert( sizeof( ExternalMemoryPropertiesKHX ) == sizeof( VkExternalMemoryPropertiesKHX ), "struct and wrapper have different size!" ); + PhysicalDeviceExternalFenceInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } - struct ExternalImageFormatPropertiesKHX - { - operator const VkExternalImageFormatPropertiesKHX&() const + operator const VkPhysicalDeviceExternalFenceInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalImageFormatPropertiesKHX const& rhs ) const + bool operator==( PhysicalDeviceExternalFenceInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( externalMemoryProperties == rhs.externalMemoryProperties ); + && ( handleType == rhs.handleType ); } - bool operator!=( ExternalImageFormatPropertiesKHX const& rhs ) const + bool operator!=( PhysicalDeviceExternalFenceInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20418,26 +21786,55 @@ namespace vk StructureType sType; public: - void* pNext; - ExternalMemoryPropertiesKHX externalMemoryProperties; + const void* pNext; + ExternalFenceHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( ExternalImageFormatPropertiesKHX ) == sizeof( VkExternalImageFormatPropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceExternalFenceInfoKHR ) == sizeof( VkPhysicalDeviceExternalFenceInfoKHR ), "struct and wrapper have different size!" ); - struct ExternalBufferPropertiesKHX + struct ExportFenceCreateInfoKHR { - operator const VkExternalBufferPropertiesKHX&() const + ExportFenceCreateInfoKHR( ExternalFenceHandleTypeFlagsKHR handleTypes_ = ExternalFenceHandleTypeFlagsKHR() ) + : sType( StructureType::eExportFenceCreateInfoKHR ) + , pNext( nullptr ) + , handleTypes( handleTypes_ ) + { + } + + ExportFenceCreateInfoKHR( VkExportFenceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceCreateInfoKHR ) ); + } + + ExportFenceCreateInfoKHR& operator=( VkExportFenceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceCreateInfoKHR ) ); + return *this; + } + ExportFenceCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportFenceCreateInfoKHR& setHandleTypes( ExternalFenceHandleTypeFlagsKHR handleTypes_ ) + { + handleTypes = handleTypes_; + return *this; + } + + operator const VkExportFenceCreateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalBufferPropertiesKHX const& rhs ) const + bool operator==( ExportFenceCreateInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( externalMemoryProperties == rhs.externalMemoryProperties ); + && ( handleTypes == rhs.handleTypes ); } - bool operator!=( ExternalBufferPropertiesKHX const& rhs ) const + bool operator!=( ExportFenceCreateInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20446,84 +21843,64 @@ namespace vk StructureType sType; public: - void* pNext; - ExternalMemoryPropertiesKHX externalMemoryProperties; - }; - static_assert( sizeof( ExternalBufferPropertiesKHX ) == sizeof( VkExternalBufferPropertiesKHX ), "struct and wrapper have different size!" ); - - enum class ExternalSemaphoreHandleTypeFlagBitsKHX - { - eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX, - eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX, - eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX, - eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX, - eFenceFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX - }; - - using ExternalSemaphoreHandleTypeFlagsKHX = Flags; - - VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHX operator|( ExternalSemaphoreHandleTypeFlagBitsKHX bit0, ExternalSemaphoreHandleTypeFlagBitsKHX bit1 ) - { - return ExternalSemaphoreHandleTypeFlagsKHX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHX operator~( ExternalSemaphoreHandleTypeFlagBitsKHX bits ) - { - return ~( ExternalSemaphoreHandleTypeFlagsKHX( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eFenceFd) - }; + const void* pNext; + ExternalFenceHandleTypeFlagsKHR handleTypes; }; + static_assert( sizeof( ExportFenceCreateInfoKHR ) == sizeof( VkExportFenceCreateInfoKHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceExternalSemaphoreInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct FenceGetWin32HandleInfoKHR { - PhysicalDeviceExternalSemaphoreInfoKHX( ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalSemaphoreInfoKHX ) + FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eFenceGetWin32HandleInfoKHR ) , pNext( nullptr ) + , fence( fence_ ) , handleType( handleType_ ) { } - PhysicalDeviceExternalSemaphoreInfoKHX( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs ) + FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHX ) ); + memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); } - PhysicalDeviceExternalSemaphoreInfoKHX& operator=( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs ) + FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHX ) ); + memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); return *this; } - PhysicalDeviceExternalSemaphoreInfoKHX& setPNext( const void* pNext_ ) + FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceExternalSemaphoreInfoKHX& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ ) + FenceGetWin32HandleInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - operator const VkPhysicalDeviceExternalSemaphoreInfoKHX&() const + operator const VkFenceGetWin32HandleInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceExternalSemaphoreInfoKHX const& rhs ) const + bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) + && ( fence == rhs.fence ) && ( handleType == rhs.handleType ); } - bool operator!=( PhysicalDeviceExternalSemaphoreInfoKHX const& rhs ) const + bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20533,128 +21910,238 @@ namespace vk public: const void* pNext; - ExternalSemaphoreHandleTypeFlagBitsKHX handleType; + Fence fence; + ExternalFenceHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHX ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - struct ExportSemaphoreCreateInfoKHX + struct FenceGetFdInfoKHR { - ExportSemaphoreCreateInfoKHX( ExternalSemaphoreHandleTypeFlagsKHX handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHX() ) - : sType( StructureType::eExportSemaphoreCreateInfoKHX ) + FenceGetFdInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eFenceGetFdInfoKHR ) , pNext( nullptr ) - , handleTypes( handleTypes_ ) + , fence( fence_ ) + , handleType( handleType_ ) { } - ExportSemaphoreCreateInfoKHX( VkExportSemaphoreCreateInfoKHX const & rhs ) + FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHX ) ); + memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); } - ExportSemaphoreCreateInfoKHX& operator=( VkExportSemaphoreCreateInfoKHX const & rhs ) + FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHX ) ); + memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); return *this; } - ExportSemaphoreCreateInfoKHX& setPNext( const void* pNext_ ) + FenceGetFdInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExportSemaphoreCreateInfoKHX& setHandleTypes( ExternalSemaphoreHandleTypeFlagsKHX handleTypes_ ) + FenceGetFdInfoKHR& setFence( Fence fence_ ) { - handleTypes = handleTypes_; + fence = fence_; + return *this; + } + + FenceGetFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; return *this; } - operator const VkExportSemaphoreCreateInfoKHX&() const + operator const VkFenceGetFdInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExportSemaphoreCreateInfoKHX const& rhs ) const + bool operator==( FenceGetFdInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); + && ( fence == rhs.fence ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( FenceGetFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Fence fence; + ExternalFenceHandleTypeFlagBitsKHR handleType; + }; + static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); + + enum class ExternalFenceFeatureFlagBitsKHR + { + eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR, + eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR + }; + + using ExternalFenceFeatureFlagsKHR = Flags; + + VULKAN_HPP_INLINE ExternalFenceFeatureFlagsKHR operator|( ExternalFenceFeatureFlagBitsKHR bit0, ExternalFenceFeatureFlagBitsKHR bit1 ) + { + return ExternalFenceFeatureFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalFenceFeatureFlagsKHR operator~( ExternalFenceFeatureFlagBitsKHR bits ) + { + return ~( ExternalFenceFeatureFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalFenceFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalFenceFeatureFlagBitsKHR::eImportable) + }; + }; + + struct ExternalFencePropertiesKHR + { + operator const VkExternalFencePropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalFencePropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) + && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) + && ( externalFenceFeatures == rhs.externalFenceFeatures ); } - bool operator!=( ExportSemaphoreCreateInfoKHX const& rhs ) const + bool operator!=( ExternalFencePropertiesKHR const& rhs ) const { return !operator==( rhs ); } - private: - StructureType sType; + private: + StructureType sType; + + public: + void* pNext; + ExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes; + ExternalFenceHandleTypeFlagsKHR compatibleHandleTypes; + ExternalFenceFeatureFlagsKHR externalFenceFeatures; + }; + static_assert( sizeof( ExternalFencePropertiesKHR ) == sizeof( VkExternalFencePropertiesKHR ), "struct and wrapper have different size!" ); + + enum class FenceImportFlagBitsKHR + { + eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR + }; + + using FenceImportFlagsKHR = Flags; + + VULKAN_HPP_INLINE FenceImportFlagsKHR operator|( FenceImportFlagBitsKHR bit0, FenceImportFlagBitsKHR bit1 ) + { + return FenceImportFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE FenceImportFlagsKHR operator~( FenceImportFlagBitsKHR bits ) + { + return ~( FenceImportFlagsKHR( bits ) ); + } - public: - const void* pNext; - ExternalSemaphoreHandleTypeFlagsKHX handleTypes; + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(FenceImportFlagBitsKHR::eTemporary) + }; }; - static_assert( sizeof( ExportSemaphoreCreateInfoKHX ) == sizeof( VkExportSemaphoreCreateInfoKHX ), "struct and wrapper have different size!" ); -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct ImportSemaphoreWin32HandleInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportFenceWin32HandleInfoKHR { - ImportSemaphoreWin32HandleInfoKHX( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagsKHX handleType_ = ExternalSemaphoreHandleTypeFlagsKHX(), HANDLE handle_ = 0 ) - : sType( StructureType::eImportSemaphoreWin32HandleInfoKHX ) + ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eImportFenceWin32HandleInfoKHR ) , pNext( nullptr ) - , semaphore( semaphore_ ) + , fence( fence_ ) + , flags( flags_ ) , handleType( handleType_ ) , handle( handle_ ) + , name( name_ ) { } - ImportSemaphoreWin32HandleInfoKHX( VkImportSemaphoreWin32HandleInfoKHX const & rhs ) + ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHX ) ); + memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); } - ImportSemaphoreWin32HandleInfoKHX& operator=( VkImportSemaphoreWin32HandleInfoKHX const & rhs ) + ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHX ) ); + memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); return *this; } - ImportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ ) + ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImportSemaphoreWin32HandleInfoKHX& setSemaphore( Semaphore semaphore_ ) + ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ ) { - semaphore = semaphore_; + fence = fence_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlagsKHR flags_ ) + { + flags = flags_; return *this; } - ImportSemaphoreWin32HandleInfoKHX& setHandleType( ExternalSemaphoreHandleTypeFlagsKHX handleType_ ) + ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - ImportSemaphoreWin32HandleInfoKHX& setHandle( HANDLE handle_ ) + ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ ) { handle = handle_; return *this; } - operator const VkImportSemaphoreWin32HandleInfoKHX&() const + ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) { - return *reinterpret_cast(this); + name = name_; + return *this; + } + + operator const VkImportFenceWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); } - bool operator==( ImportSemaphoreWin32HandleInfoKHX const& rhs ) const + bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) + && ( fence == rhs.fence ) + && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ); + && ( handle == rhs.handle ) + && ( name == rhs.name ); } - bool operator!=( ImportSemaphoreWin32HandleInfoKHX const& rhs ) const + bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20664,73 +22151,83 @@ namespace vk public: const void* pNext; - Semaphore semaphore; - ExternalSemaphoreHandleTypeFlagsKHX handleType; + Fence fence; + FenceImportFlagsKHR flags; + ExternalFenceHandleTypeFlagBitsKHR handleType; HANDLE handle; + LPCWSTR name; }; - static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHX ) == sizeof( VkImportSemaphoreWin32HandleInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - struct ImportSemaphoreFdInfoKHX + struct ImportFenceFdInfoKHR { - ImportSemaphoreFdInfoKHX( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd, int fd_ = 0 ) - : sType( StructureType::eImportSemaphoreFdInfoKHX ) + ImportFenceFdInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) + : sType( StructureType::eImportFenceFdInfoKHR ) , pNext( nullptr ) - , semaphore( semaphore_ ) + , fence( fence_ ) + , flags( flags_ ) , handleType( handleType_ ) , fd( fd_ ) { } - ImportSemaphoreFdInfoKHX( VkImportSemaphoreFdInfoKHX const & rhs ) + ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHX ) ); + memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); } - ImportSemaphoreFdInfoKHX& operator=( VkImportSemaphoreFdInfoKHX const & rhs ) + ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHX ) ); + memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); return *this; } - ImportSemaphoreFdInfoKHX& setPNext( const void* pNext_ ) + ImportFenceFdInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImportSemaphoreFdInfoKHX& setSemaphore( Semaphore semaphore_ ) + ImportFenceFdInfoKHR& setFence( Fence fence_ ) { - semaphore = semaphore_; + fence = fence_; + return *this; + } + + ImportFenceFdInfoKHR& setFlags( FenceImportFlagsKHR flags_ ) + { + flags = flags_; return *this; } - ImportSemaphoreFdInfoKHX& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ ) + ImportFenceFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - ImportSemaphoreFdInfoKHX& setFd( int fd_ ) + ImportFenceFdInfoKHR& setFd( int fd_ ) { fd = fd_; return *this; } - operator const VkImportSemaphoreFdInfoKHX&() const + operator const VkImportFenceFdInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImportSemaphoreFdInfoKHX const& rhs ) const + bool operator==( ImportFenceFdInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) + && ( fence == rhs.fence ) + && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); } - bool operator!=( ImportSemaphoreFdInfoKHX const& rhs ) const + bool operator!=( ImportFenceFdInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20740,69 +22237,12 @@ namespace vk public: const void* pNext; - Semaphore semaphore; - ExternalSemaphoreHandleTypeFlagBitsKHX handleType; + Fence fence; + FenceImportFlagsKHR flags; + ExternalFenceHandleTypeFlagBitsKHR handleType; int fd; }; - static_assert( sizeof( ImportSemaphoreFdInfoKHX ) == sizeof( VkImportSemaphoreFdInfoKHX ), "struct and wrapper have different size!" ); - - enum class ExternalSemaphoreFeatureFlagBitsKHX - { - eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX, - eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX - }; - - using ExternalSemaphoreFeatureFlagsKHX = Flags; - - VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHX operator|( ExternalSemaphoreFeatureFlagBitsKHX bit0, ExternalSemaphoreFeatureFlagBitsKHX bit1 ) - { - return ExternalSemaphoreFeatureFlagsKHX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHX operator~( ExternalSemaphoreFeatureFlagBitsKHX bits ) - { - return ~( ExternalSemaphoreFeatureFlagsKHX( bits ) ); - } - - template <> struct FlagTraits - { - enum - { - allFlags = VkFlags(ExternalSemaphoreFeatureFlagBitsKHX::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBitsKHX::eImportable) - }; - }; - - struct ExternalSemaphorePropertiesKHX - { - operator const VkExternalSemaphorePropertiesKHX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ExternalSemaphorePropertiesKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) - && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); - } - - bool operator!=( ExternalSemaphorePropertiesKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType; - - public: - void* pNext; - ExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes; - ExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes; - ExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures; - }; - static_assert( sizeof( ExternalSemaphorePropertiesKHX ) == sizeof( VkExternalSemaphorePropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); enum class SurfaceCounterFlagBitsEXT { @@ -24115,52 +25555,76 @@ namespace vk void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlagsKHR flags = CommandPoolTrimFlagsKHR() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - Result getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const; +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ResultValueType::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ResultValueType::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ResultValueType::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ResultValueType::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const; + ResultValueType::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - Result getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, MemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties ) const; +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle ) const; + ResultValueType::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - Result getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd ) const; + Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const; + ResultValueType::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - Result getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, MemoryFdPropertiesKHX* pMemoryFdProperties ) const; + Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd ) const; + ResultValueType::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - Result getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const; +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const; + ResultValueType::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - Result importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo ) const; +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX & importSemaphoreWin32HandleInfo ) const; + ResultValueType::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - Result getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd ) const; + Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const; + ResultValueType::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - Result importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo ) const; + Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX & importSemaphoreFdInfo ) const; + ResultValueType::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo ) const; @@ -24246,6 +25710,22 @@ namespace vk typename ResultValueType>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + MemoryRequirements2KHR getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + MemoryRequirements2KHR getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2KHR* pSparseMemoryRequirements ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template > + std::vector getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const @@ -26071,113 +27551,167 @@ namespace vk vkTrimCommandPoolKHR( m_device, static_cast( commandPool ), static_cast( flags ) ); } -#ifdef VK_USE_PLATFORM_WIN32_KHX - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const + { + return static_cast( vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const + { + HANDLE handle; + Result result = static_cast( vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + return createResultValue( result, handle, "vk::Device::getMemoryWin32HandleKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const + { + return static_cast( vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast( handleType ), handle, reinterpret_cast( pMemoryWin32HandleProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle ) const + { + MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; + Result result = static_cast( vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast( handleType ), handle, reinterpret_cast( &memoryWin32HandleProperties ) ) ); + return createResultValue( result, memoryWin32HandleProperties, "vk::Device::getMemoryWin32HandlePropertiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const + { + return static_cast( vkGetMemoryFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const + { + int fd; + Result result = static_cast( vkGetMemoryFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + return createResultValue( result, fd, "vk::Device::getMemoryFdKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties ) const + { + return static_cast( vkGetMemoryFdPropertiesKHR( m_device, static_cast( handleType ), fd, reinterpret_cast( pMemoryFdProperties ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd ) const + { + MemoryFdPropertiesKHR memoryFdProperties; + Result result = static_cast( vkGetMemoryFdPropertiesKHR( m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); + return createResultValue( result, memoryFdProperties, "vk::Device::getMemoryFdPropertiesKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const { - return static_cast( vkGetMemoryWin32HandleKHX( m_device, static_cast( memory ), static_cast( handleType ), pHandle ) ); + return static_cast( vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const { HANDLE handle; - Result result = static_cast( vkGetMemoryWin32HandleKHX( m_device, static_cast( memory ), static_cast( handleType ), &handle ) ); - return createResultValue( result, handle, "vk::Device::getMemoryWin32HandleKHX" ); + Result result = static_cast( vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + return createResultValue( result, handle, "vk::Device::getSemaphoreWin32HandleKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, MemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties ) const +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const { - return static_cast( vkGetMemoryWin32HandlePropertiesKHX( m_device, static_cast( handleType ), handle, reinterpret_cast( pMemoryWin32HandleProperties ) ) ); + return static_cast( vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( pImportSemaphoreWin32HandleInfo ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle ) const + VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const { - MemoryWin32HandlePropertiesKHX memoryWin32HandleProperties; - Result result = static_cast( vkGetMemoryWin32HandlePropertiesKHX( m_device, static_cast( handleType ), handle, reinterpret_cast( &memoryWin32HandleProperties ) ) ); - return createResultValue( result, memoryWin32HandleProperties, "vk::Device::getMemoryWin32HandlePropertiesKHX" ); + Result result = static_cast( vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); + return createResultValue( result, "vk::Device::importSemaphoreWin32HandleKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - VULKAN_HPP_INLINE Result Device::getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd ) const + VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const { - return static_cast( vkGetMemoryFdKHX( m_device, static_cast( memory ), static_cast( handleType ), pFd ) ); + return static_cast( vkGetSemaphoreFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const { int fd; - Result result = static_cast( vkGetMemoryFdKHX( m_device, static_cast( memory ), static_cast( handleType ), &fd ) ); - return createResultValue( result, fd, "vk::Device::getMemoryFdKHX" ); + Result result = static_cast( vkGetSemaphoreFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + return createResultValue( result, fd, "vk::Device::getSemaphoreFdKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, MemoryFdPropertiesKHX* pMemoryFdProperties ) const + VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const { - return static_cast( vkGetMemoryFdPropertiesKHX( m_device, static_cast( handleType ), fd, reinterpret_cast( pMemoryFdProperties ) ) ); + return static_cast( vkImportSemaphoreFdKHR( m_device, reinterpret_cast( pImportSemaphoreFdInfo ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd ) const + VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const { - MemoryFdPropertiesKHX memoryFdProperties; - Result result = static_cast( vkGetMemoryFdPropertiesKHX( m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); - return createResultValue( result, memoryFdProperties, "vk::Device::getMemoryFdPropertiesKHX" ); + Result result = static_cast( vkImportSemaphoreFdKHR( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ) ); + return createResultValue( result, "vk::Device::importSemaphoreFdKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const { - return static_cast( vkGetSemaphoreWin32HandleKHX( m_device, static_cast( semaphore ), static_cast( handleType ), pHandle ) ); + return static_cast( vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const { HANDLE handle; - Result result = static_cast( vkGetSemaphoreWin32HandleKHX( m_device, static_cast( semaphore ), static_cast( handleType ), &handle ) ); - return createResultValue( result, handle, "vk::Device::getSemaphoreWin32HandleKHX" ); + Result result = static_cast( vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + return createResultValue( result, handle, "vk::Device::getFenceWin32HandleKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo ) const +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const { - return static_cast( vkImportSemaphoreWin32HandleKHX( m_device, reinterpret_cast( pImportSemaphoreWin32HandleInfo ) ) ); + return static_cast( vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( pImportFenceWin32HandleInfo ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX & importSemaphoreWin32HandleInfo ) const + VULKAN_HPP_INLINE ResultValueType::type Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const { - Result result = static_cast( vkImportSemaphoreWin32HandleKHX( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); - return createResultValue( result, "vk::Device::importSemaphoreWin32HandleKHX" ); + Result result = static_cast( vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( &importFenceWin32HandleInfo ) ) ); + return createResultValue( result, "vk::Device::importFenceWin32HandleKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd ) const + VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const { - return static_cast( vkGetSemaphoreFdKHX( m_device, static_cast( semaphore ), static_cast( handleType ), pFd ) ); + return static_cast( vkGetFenceFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const { int fd; - Result result = static_cast( vkGetSemaphoreFdKHX( m_device, static_cast( semaphore ), static_cast( handleType ), &fd ) ); - return createResultValue( result, fd, "vk::Device::getSemaphoreFdKHX" ); + Result result = static_cast( vkGetFenceFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + return createResultValue( result, fd, "vk::Device::getFenceFdKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo ) const + VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo ) const { - return static_cast( vkImportSemaphoreFdKHX( m_device, reinterpret_cast( pImportSemaphoreFdInfo ) ) ); + return static_cast( vkImportFenceFdKHR( m_device, reinterpret_cast( pImportFenceFdInfo ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX & importSemaphoreFdInfo ) const + VULKAN_HPP_INLINE ResultValueType::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const { - Result result = static_cast( vkImportSemaphoreFdKHX( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ) ); - return createResultValue( result, "vk::Device::importSemaphoreFdKHX" ); + Result result = static_cast( vkImportFenceFdKHR( m_device, reinterpret_cast( &importFenceFdInfo ) ) ); + return createResultValue( result, "vk::Device::importFenceFdKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -26409,6 +27943,49 @@ namespace vk } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const + { + vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const + { + MemoryRequirements2KHR memoryRequirements; + vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const + { + vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const + { + MemoryRequirements2KHR memoryRequirements; + vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2KHR* pSparseMemoryRequirements ) const + { + vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast( pSparseMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const + { + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, reinterpret_cast( sparseMemoryRequirements.data() ) ); + return sparseMemoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifndef VULKAN_HPP_NO_SMART_HANDLE class DeviceDeleter; using UniqueDevice = UniqueHandle; @@ -26650,14 +28227,19 @@ namespace vk std::vector getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - void getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, ExternalBufferPropertiesKHX* pExternalBufferProperties ) const; + void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, ExternalBufferPropertiesKHR* pExternalBufferProperties ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ExternalBufferPropertiesKHR getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR & externalBufferInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ExternalBufferPropertiesKHX getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX & externalBufferInfo ) const; + ExternalSemaphorePropertiesKHR getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR & externalSemaphoreInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - void getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties ) const; + void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, ExternalFencePropertiesKHR* pExternalFenceProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ExternalSemaphorePropertiesKHX getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX & externalSemaphoreInfo ) const; + ExternalFencePropertiesKHR getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR & externalFenceInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -27306,32 +28888,45 @@ namespace vk } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, ExternalBufferPropertiesKHX* pExternalBufferProperties ) const + VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, ExternalBufferPropertiesKHR* pExternalBufferProperties ) const { - vkGetPhysicalDeviceExternalBufferPropertiesKHX( m_physicalDevice, reinterpret_cast( pExternalBufferInfo ), reinterpret_cast( pExternalBufferProperties ) ); + vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalBufferInfo ), reinterpret_cast( pExternalBufferProperties ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ExternalBufferPropertiesKHX PhysicalDevice::getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX & externalBufferInfo ) const + VULKAN_HPP_INLINE ExternalBufferPropertiesKHR PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR & externalBufferInfo ) const { - ExternalBufferPropertiesKHX externalBufferProperties; - vkGetPhysicalDeviceExternalBufferPropertiesKHX( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); + ExternalBufferPropertiesKHR externalBufferProperties; + vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); return externalBufferProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties ) const + VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties ) const { - vkGetPhysicalDeviceExternalSemaphorePropertiesKHX( m_physicalDevice, reinterpret_cast( pExternalSemaphoreInfo ), reinterpret_cast( pExternalSemaphoreProperties ) ); + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalSemaphoreInfo ), reinterpret_cast( pExternalSemaphoreProperties ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ExternalSemaphorePropertiesKHX PhysicalDevice::getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX & externalSemaphoreInfo ) const + VULKAN_HPP_INLINE ExternalSemaphorePropertiesKHR PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR & externalSemaphoreInfo ) const { - ExternalSemaphorePropertiesKHX externalSemaphoreProperties; - vkGetPhysicalDeviceExternalSemaphorePropertiesKHX( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); + ExternalSemaphorePropertiesKHR externalSemaphoreProperties; + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); return externalSemaphoreProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, ExternalFencePropertiesKHR* pExternalFenceProperties ) const + { + vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalFenceInfo ), reinterpret_cast( pExternalFenceProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ExternalFencePropertiesKHR PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR & externalFenceInfo ) const + { + ExternalFencePropertiesKHR externalFenceProperties; + vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalFenceInfo ), reinterpret_cast( &externalFenceProperties ) ); + return externalFenceProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const { @@ -29592,28 +31187,33 @@ namespace vk case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN"; case StructureType::ePhysicalDeviceGroupPropertiesKHX: return "PhysicalDeviceGroupPropertiesKHX"; case StructureType::eDeviceGroupDeviceCreateInfoKHX: return "DeviceGroupDeviceCreateInfoKHX"; - case StructureType::ePhysicalDeviceExternalImageFormatInfoKHX: return "PhysicalDeviceExternalImageFormatInfoKHX"; - case StructureType::eExternalImageFormatPropertiesKHX: return "ExternalImageFormatPropertiesKHX"; - case StructureType::ePhysicalDeviceExternalBufferInfoKHX: return "PhysicalDeviceExternalBufferInfoKHX"; - case StructureType::eExternalBufferPropertiesKHX: return "ExternalBufferPropertiesKHX"; - case StructureType::ePhysicalDeviceIdPropertiesKHX: return "PhysicalDeviceIdPropertiesKHX"; - case StructureType::eExternalMemoryBufferCreateInfoKHX: return "ExternalMemoryBufferCreateInfoKHX"; - case StructureType::eExternalMemoryImageCreateInfoKHX: return "ExternalMemoryImageCreateInfoKHX"; - case StructureType::eExportMemoryAllocateInfoKHX: return "ExportMemoryAllocateInfoKHX"; - case StructureType::eImportMemoryWin32HandleInfoKHX: return "ImportMemoryWin32HandleInfoKHX"; - case StructureType::eExportMemoryWin32HandleInfoKHX: return "ExportMemoryWin32HandleInfoKHX"; - case StructureType::eMemoryWin32HandlePropertiesKHX: return "MemoryWin32HandlePropertiesKHX"; - case StructureType::eImportMemoryFdInfoKHX: return "ImportMemoryFdInfoKHX"; - case StructureType::eMemoryFdPropertiesKHX: return "MemoryFdPropertiesKHX"; - case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHX: return "Win32KeyedMutexAcquireReleaseInfoKHX"; - case StructureType::ePhysicalDeviceExternalSemaphoreInfoKHX: return "PhysicalDeviceExternalSemaphoreInfoKHX"; - case StructureType::eExternalSemaphorePropertiesKHX: return "ExternalSemaphorePropertiesKHX"; - case StructureType::eExportSemaphoreCreateInfoKHX: return "ExportSemaphoreCreateInfoKHX"; - case StructureType::eImportSemaphoreWin32HandleInfoKHX: return "ImportSemaphoreWin32HandleInfoKHX"; - case StructureType::eExportSemaphoreWin32HandleInfoKHX: return "ExportSemaphoreWin32HandleInfoKHX"; - case StructureType::eD3D12FenceSubmitInfoKHX: return "D3D12FenceSubmitInfoKHX"; - case StructureType::eImportSemaphoreFdInfoKHX: return "ImportSemaphoreFdInfoKHX"; + case StructureType::ePhysicalDeviceExternalImageFormatInfoKHR: return "PhysicalDeviceExternalImageFormatInfoKHR"; + case StructureType::eExternalImageFormatPropertiesKHR: return "ExternalImageFormatPropertiesKHR"; + case StructureType::ePhysicalDeviceExternalBufferInfoKHR: return "PhysicalDeviceExternalBufferInfoKHR"; + case StructureType::eExternalBufferPropertiesKHR: return "ExternalBufferPropertiesKHR"; + case StructureType::ePhysicalDeviceIdPropertiesKHR: return "PhysicalDeviceIdPropertiesKHR"; + case StructureType::eExternalMemoryBufferCreateInfoKHR: return "ExternalMemoryBufferCreateInfoKHR"; + case StructureType::eExternalMemoryImageCreateInfoKHR: return "ExternalMemoryImageCreateInfoKHR"; + case StructureType::eExportMemoryAllocateInfoKHR: return "ExportMemoryAllocateInfoKHR"; + case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR"; + case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR"; + case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR"; + case StructureType::eMemoryGetWin32HandleInfoKHR: return "MemoryGetWin32HandleInfoKHR"; + case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR"; + case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR"; + case StructureType::eMemoryGetFdInfoKHR: return "MemoryGetFdInfoKHR"; + case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR"; + case StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR: return "PhysicalDeviceExternalSemaphoreInfoKHR"; + case StructureType::eExternalSemaphorePropertiesKHR: return "ExternalSemaphorePropertiesKHR"; + case StructureType::eExportSemaphoreCreateInfoKHR: return "ExportSemaphoreCreateInfoKHR"; + case StructureType::eImportSemaphoreWin32HandleInfoKHR: return "ImportSemaphoreWin32HandleInfoKHR"; + case StructureType::eExportSemaphoreWin32HandleInfoKHR: return "ExportSemaphoreWin32HandleInfoKHR"; + case StructureType::eD3D12FenceSubmitInfoKHR: return "D3D12FenceSubmitInfoKHR"; + case StructureType::eSemaphoreGetWin32HandleInfoKHR: return "SemaphoreGetWin32HandleInfoKHR"; + case StructureType::eImportSemaphoreFdInfoKHR: return "ImportSemaphoreFdInfoKHR"; + case StructureType::eSemaphoreGetFdInfoKHR: return "SemaphoreGetFdInfoKHR"; case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR: return "PhysicalDevicePushDescriptorPropertiesKHR"; + case StructureType::ePhysicalDevice16BitStorageFeaturesKHR: return "PhysicalDevice16BitStorageFeaturesKHR"; case StructureType::ePresentRegionsKHR: return "PresentRegionsKHR"; case StructureType::eDescriptorUpdateTemplateCreateInfoKHR: return "DescriptorUpdateTemplateCreateInfoKHR"; case StructureType::eObjectTableCreateInfoNVX: return "ObjectTableCreateInfoNVX"; @@ -29635,13 +31235,29 @@ namespace vk case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT"; case StructureType::eHdrMetadataEXT: return "HdrMetadataEXT"; case StructureType::eSharedPresentSurfaceCapabilitiesKHR: return "SharedPresentSurfaceCapabilitiesKHR"; + case StructureType::ePhysicalDeviceExternalFenceInfoKHR: return "PhysicalDeviceExternalFenceInfoKHR"; + case StructureType::eExternalFencePropertiesKHR: return "ExternalFencePropertiesKHR"; + case StructureType::eExportFenceCreateInfoKHR: return "ExportFenceCreateInfoKHR"; + case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR"; + case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR"; + case StructureType::eFenceGetWin32HandleInfoKHR: return "FenceGetWin32HandleInfoKHR"; + case StructureType::eImportFenceFdInfoKHR: return "ImportFenceFdInfoKHR"; + case StructureType::eFenceGetFdInfoKHR: return "FenceGetFdInfoKHR"; case StructureType::ePhysicalDeviceSurfaceInfo2KHR: return "PhysicalDeviceSurfaceInfo2KHR"; case StructureType::eSurfaceCapabilities2KHR: return "SurfaceCapabilities2KHR"; case StructureType::eSurfaceFormat2KHR: return "SurfaceFormat2KHR"; + case StructureType::ePhysicalDeviceVariablePointerFeaturesKHR: return "PhysicalDeviceVariablePointerFeaturesKHR"; case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK"; case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK"; + case StructureType::eMemoryDedicatedRequirementsKHR: return "MemoryDedicatedRequirementsKHR"; + case StructureType::eMemoryDedicatedAllocateInfoKHR: return "MemoryDedicatedAllocateInfoKHR"; case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT: return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT"; case StructureType::eSamplerReductionModeCreateInfoEXT: return "SamplerReductionModeCreateInfoEXT"; + case StructureType::eBufferMemoryRequirementsInfo2KHR: return "BufferMemoryRequirementsInfo2KHR"; + case StructureType::eImageMemoryRequirementsInfo2KHR: return "ImageMemoryRequirementsInfo2KHR"; + case StructureType::eImageSparseMemoryRequirementsInfo2KHR: return "ImageSparseMemoryRequirementsInfo2KHR"; + case StructureType::eMemoryRequirements2KHR: return "MemoryRequirements2KHR"; + case StructureType::eSparseImageMemoryRequirements2KHR: return "SparseImageMemoryRequirements2KHR"; case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT: return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT"; case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT"; case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT: return "PipelineColorBlendAdvancedStateCreateInfoEXT"; @@ -30815,97 +32431,173 @@ namespace vk return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsKHR value) + { + switch (value) + { + case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd"; + case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32"; + case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture: return "D3D11Texture"; + case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt: return "D3D11TextureKmt"; + case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap: return "D3D12Heap"; + case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource: return "D3D12Resource"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) result += "D3D11Texture | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) result += "D3D11TextureKmt | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) result += "D3D12Heap | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) result += "D3D12Resource | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsKHR value) + { + switch (value) + { + case ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly: return "DedicatedOnly"; + case ExternalMemoryFeatureFlagBitsKHR::eExportable: return "Exportable"; + case ExternalMemoryFeatureFlagBitsKHR::eImportable: return "Importable"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly) result += "DedicatedOnly | "; + if (value & ExternalMemoryFeatureFlagBitsKHR::eExportable) result += "Exportable | "; + if (value & ExternalMemoryFeatureFlagBitsKHR::eImportable) result += "Importable | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBitsKHR value) + { + switch (value) + { + case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd"; + case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32"; + case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence: return "D3D12Fence"; + case ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd: return "SyncFd"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | "; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence) result += "D3D12Fence | "; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd) result += "SyncFd | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBitsKHR value) + { + switch (value) + { + case ExternalSemaphoreFeatureFlagBitsKHR::eExportable: return "Exportable"; + case ExternalSemaphoreFeatureFlagBitsKHR::eImportable: return "Importable"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalSemaphoreFeatureFlagBitsKHR::eExportable) result += "Exportable | "; + if (value & ExternalSemaphoreFeatureFlagBitsKHR::eImportable) result += "Importable | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagBitsKHR value) { switch (value) { - case ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd: return "OpaqueFd"; - case ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32: return "OpaqueWin32"; - case ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalMemoryHandleTypeFlagBitsKHX::eD3D11Texture: return "D3D11Texture"; - case ExternalMemoryHandleTypeFlagBitsKHX::eD3D11TextureKmt: return "D3D11TextureKmt"; - case ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Heap: return "D3D12Heap"; - case ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Resource: return "D3D12Resource"; + case SemaphoreImportFlagBitsKHR::eTemporary: return "Temporary"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsKHX value) + VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagsKHR value) { if (!value) return "{}"; std::string result; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D11Texture) result += "D3D11Texture | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D11TextureKmt) result += "D3D11TextureKmt | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Heap) result += "D3D12Heap | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Resource) result += "D3D12Resource | "; + if (value & SemaphoreImportFlagBitsKHR::eTemporary) result += "Temporary | "; return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagBitsKHR value) { switch (value) { - case ExternalMemoryFeatureFlagBitsKHX::eDedicatedOnly: return "DedicatedOnly"; - case ExternalMemoryFeatureFlagBitsKHX::eExportable: return "Exportable"; - case ExternalMemoryFeatureFlagBitsKHX::eImportable: return "Importable"; + case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd"; + case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32"; + case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalFenceHandleTypeFlagBitsKHR::eSyncFd: return "SyncFd"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagsKHR value) { if (!value) return "{}"; std::string result; - if (value & ExternalMemoryFeatureFlagBitsKHX::eDedicatedOnly) result += "DedicatedOnly | "; - if (value & ExternalMemoryFeatureFlagBitsKHX::eExportable) result += "Exportable | "; - if (value & ExternalMemoryFeatureFlagBitsKHX::eImportable) result += "Importable | "; + if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | "; + if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalFenceHandleTypeFlagBitsKHR::eSyncFd) result += "SyncFd | "; return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBitsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagBitsKHR value) { switch (value) { - case ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd: return "OpaqueFd"; - case ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32: return "OpaqueWin32"; - case ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalSemaphoreHandleTypeFlagBitsKHX::eD3D12Fence: return "D3D12Fence"; - case ExternalSemaphoreHandleTypeFlagBitsKHX::eFenceFd: return "FenceFd"; + case ExternalFenceFeatureFlagBitsKHR::eExportable: return "Exportable"; + case ExternalFenceFeatureFlagBitsKHR::eImportable: return "Importable"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagsKHR value) { if (!value) return "{}"; std::string result; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eD3D12Fence) result += "D3D12Fence | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eFenceFd) result += "FenceFd | "; + if (value & ExternalFenceFeatureFlagBitsKHR::eExportable) result += "Exportable | "; + if (value & ExternalFenceFeatureFlagBitsKHR::eImportable) result += "Importable | "; return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBitsKHX value) + VULKAN_HPP_INLINE std::string to_string(FenceImportFlagBitsKHR value) { switch (value) { - case ExternalSemaphoreFeatureFlagBitsKHX::eExportable: return "Exportable"; - case ExternalSemaphoreFeatureFlagBitsKHX::eImportable: return "Importable"; + case FenceImportFlagBitsKHR::eTemporary: return "Temporary"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagsKHX value) + VULKAN_HPP_INLINE std::string to_string(FenceImportFlagsKHR value) { if (!value) return "{}"; std::string result; - if (value & ExternalSemaphoreFeatureFlagBitsKHX::eExportable) result += "Exportable | "; - if (value & ExternalSemaphoreFeatureFlagBitsKHX::eImportable) result += "Importable | "; + if (value & FenceImportFlagBitsKHR::eTemporary) result += "Temporary | "; return "{" + result.substr(0, result.size() - 3) + "}"; } diff --git a/layers/linux/VkLayer_core_validation.json b/layers/linux/VkLayer_core_validation.json index 437c41d9..f7f91564 100644 --- a/layers/linux/VkLayer_core_validation.json +++ b/layers/linux/VkLayer_core_validation.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_LUNARG_core_validation", "type": "GLOBAL", "library_path": "./libVkLayer_core_validation.so", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "LunarG Validation Layer", "instance_extensions": [ diff --git a/layers/linux/VkLayer_object_tracker.json b/layers/linux/VkLayer_object_tracker.json index 68fa9d5a..e5cb7a13 100644 --- a/layers/linux/VkLayer_object_tracker.json +++ b/layers/linux/VkLayer_object_tracker.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_LUNARG_object_tracker", "type": "GLOBAL", "library_path": "./libVkLayer_object_tracker.so", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "LunarG Validation Layer", "instance_extensions": [ diff --git a/layers/linux/VkLayer_parameter_validation.json b/layers/linux/VkLayer_parameter_validation.json index e10b964d..1290ac54 100644 --- a/layers/linux/VkLayer_parameter_validation.json +++ b/layers/linux/VkLayer_parameter_validation.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_LUNARG_parameter_validation", "type": "GLOBAL", "library_path": "./libVkLayer_parameter_validation.so", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "LunarG Validation Layer", "instance_extensions": [ diff --git a/layers/linux/VkLayer_standard_validation.json b/layers/linux/VkLayer_standard_validation.json index 6b52306e..e5f52394 100644 --- a/layers/linux/VkLayer_standard_validation.json +++ b/layers/linux/VkLayer_standard_validation.json @@ -3,7 +3,7 @@ "layer": { "name": "VK_LAYER_LUNARG_standard_validation", "type": "GLOBAL", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "LunarG Standard Validation", "component_layers": [ diff --git a/layers/linux/VkLayer_threading.json b/layers/linux/VkLayer_threading.json index d48872ce..3fba647c 100644 --- a/layers/linux/VkLayer_threading.json +++ b/layers/linux/VkLayer_threading.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_GOOGLE_threading", "type": "GLOBAL", "library_path": "./libVkLayer_threading.so", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "Google Validation Layer", "instance_extensions": [ diff --git a/layers/linux/VkLayer_unique_objects.json b/layers/linux/VkLayer_unique_objects.json index 2f9d95ca..f2bc92a9 100644 --- a/layers/linux/VkLayer_unique_objects.json +++ b/layers/linux/VkLayer_unique_objects.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_GOOGLE_unique_objects", "type": "GLOBAL", "library_path": "./libVkLayer_unique_objects.so", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "Google Validation Layer" } diff --git a/layers/object_tracker.cpp b/layers/object_tracker.cpp index 87903173..43ceaa11 100644 --- a/layers/object_tracker.cpp +++ b/layers/object_tracker.cpp @@ -4130,53 +4130,56 @@ VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer c } } -// VK_KHR_maintenance1 Extension -VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) { - bool skip = VK_FALSE; +// VK_KHR_external_fence_capabilities Extension +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR *pExternalFenceInfo, + VkExternalFencePropertiesKHR *pExternalFenceProperties) { + bool skip = false; + { std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_UNDEFINED, + skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); + } if (!skip) { - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - dev_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags); + get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } } -// VK_KHR_push_descriptor Extension -VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites) { +// VK_KHR_external_memory_capabilities Extension +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo, + VkExternalBufferPropertiesKHR *pExternalBufferProperties) { bool skip = false; + { std::unique_lock lock(global_lock); - skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_UNDEFINED, + skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - lock.unlock(); + } if (!skip) { - get_dispatch_table(ot_device_table_map, commandBuffer) - ->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); + get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } } -// VK_KHX_device_group Extension -VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlagsKHX *pPeerMemoryFeatures) { +// VK_KHR_external_memory_fd Extension +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pGetFdInfo->memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); lock.unlock(); - if (!skip) { - get_dispatch_table(ot_device_table_map, device) - ->GetDeviceGroupPeerMemoryFeaturesKHX(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; } + VkResult result = VK_SUCCESS; + result = get_dispatch_table(ot_device_table_map, device)->GetMemoryFdKHR(device, pGetFdInfo, pFd); + return result; } -VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(VkDevice device, uint32_t bindInfoCount, - const VkBindBufferMemoryInfoKHX *pBindInfos) { +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, + VkMemoryFdPropertiesKHR *pMemoryFdProperties) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); @@ -4185,94 +4188,118 @@ VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(VkDevice device, uint32_t bi return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->BindBufferMemory2KHX(device, bindInfoCount, pBindInfos); + result = get_dispatch_table(ot_device_table_map, device)->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); return result; } -VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(VkDevice device, uint32_t bindInfoCount, - const VkBindImageMemoryInfoKHX *pBindInfos) { +// VK_KHR_external_fence_fd extension + +VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pImportFenceFdInfo->fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); lock.unlock(); if (skip) { return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->BindImageMemory2KHX(device, bindInfoCount, pBindInfos); + result = get_dispatch_table(ot_device_table_map, device)->ImportFenceFdKHR(device, pImportFenceFdInfo); return result; } -VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(VkCommandBuffer commandBuffer, uint32_t deviceMask) { +VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd) { bool skip = false; std::unique_lock lock(global_lock); - skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_UNDEFINED, + skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pGetFdInfo->fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); lock.unlock(); - if (!skip) { - get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetDeviceMaskKHX(commandBuffer, deviceMask); + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; } + VkResult result = VK_SUCCESS; + result = get_dispatch_table(ot_device_table_map, device)->GetFenceFdKHR(device, pGetFdInfo, pFd); + return result; } -VKAPI_ATTR VkResult VKAPI_CALL -GetDeviceGroupPresentCapabilitiesKHX(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX *pDeviceGroupPresentCapabilities) { +#ifdef VK_USE_PLATFORM_WIN32_KHR +// VK_KHR_external_fence_win32 extension + +VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(VkDevice device, + const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pImportFenceWin32HandleInfo->fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); lock.unlock(); if (skip) { return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device) - ->GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities); + result = get_dispatch_table(ot_device_table_map, device)->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(VkDevice device, VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHX *pModes) { +VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, + HANDLE *pHandle) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pGetWin32HandleInfo->fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); lock.unlock(); if (skip) { return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes); + result = get_dispatch_table(ot_device_table_map, device)->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); return result; } -VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(VkDevice device, const VkAcquireNextImageInfoKHX *pAcquireInfo, - uint32_t *pImageIndex) { +#endif // VK_USE_PLATFORM_WIN32_KHR + +// VK_KHR_external_memory_win32 Extension +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, + HANDLE *pHandle) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pGetWin32HandleInfo->memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); lock.unlock(); if (skip) { return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex); + result = get_dispatch_table(ot_device_table_map, device)->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); return result; } -VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, - uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, - uint32_t groupCountZ) { +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties) { bool skip = false; std::unique_lock lock(global_lock); - skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); lock.unlock(); - if (!skip) { - get_dispatch_table(ot_device_table_map, commandBuffer) - ->CmdDispatchBaseKHX(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; } + VkResult result = VK_SUCCESS; + result = get_dispatch_table(ot_device_table_map, device) + ->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); + return result; } +#endif // VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR void VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - uint32_t *pRectCount, VkRect2D *pRects) { +// VK_KHR_external_semaphore_capabilities Extension +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR *pExternalSemaphoreProperties) { bool skip = false; { std::unique_lock lock(global_lock); @@ -4281,109 +4308,183 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevic } if (!skip) { get_dispatch_table(ot_instance_table_map, physicalDevice) - ->GetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, pRectCount, pRects); + ->GetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } } -// VK_KHX_device_group_creation Extension -VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX( - VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) { +// VK_KHR_external_semaphore_fd Extension +VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) { bool skip = false; std::unique_lock lock(global_lock); - skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_UNDEFINED, + skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; + } + VkResult result = VK_SUCCESS; + result = get_dispatch_table(ot_device_table_map, device)->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd) { + bool skip = false; + std::unique_lock lock(global_lock); + skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pGetFdInfo->semaphore, kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); lock.unlock(); if (skip) { return VK_ERROR_VALIDATION_FAILED_EXT; } - VkResult result = get_dispatch_table(ot_instance_table_map, instance) - ->EnumeratePhysicalDeviceGroupsKHX(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - { - lock.lock(); - if (result == VK_SUCCESS) { - if (nullptr != pPhysicalDeviceGroupProperties) { - // NOTE: Each physical device should only appear in one group - for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) { - for (uint32_t j = 0; j < pPhysicalDeviceGroupProperties[i].physicalDeviceCount; j++) { - CreateObject(instance, pPhysicalDeviceGroupProperties[i].physicalDevices[j], - kVulkanObjectTypePhysicalDevice, nullptr); + VkResult result = VK_SUCCESS; + result = get_dispatch_table(ot_device_table_map, device)->GetSemaphoreFdKHR(device, pGetFdInfo, pFd); + return result; } + +// VK_KHR_external_semaphore_win32 Extension +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL +ImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo) { + bool skip = false; + std::unique_lock lock(global_lock); + skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pImportSemaphoreWin32HandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, + VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; } + VkResult result = VK_SUCCESS; + result = + get_dispatch_table(ot_device_table_map, device)->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); + return result; } - } + +VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, + HANDLE *pHandle) { + bool skip = false; + std::unique_lock lock(global_lock); + skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pGetWin32HandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); lock.unlock(); + if (skip) { + return VK_ERROR_VALIDATION_FAILED_EXT; } + VkResult result = VK_SUCCESS; + result = get_dispatch_table(ot_device_table_map, device)->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); return result; } +#endif // VK_USE_PLATFORM_WIN32_KHR -// VK_KHX_external_memory_capabilities Extension -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHX( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX *pExternalBufferInfo, - VkExternalBufferPropertiesKHX *pExternalBufferProperties) { - bool skip = false; - { - std::unique_lock lock(global_lock); - skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); +// VK_KHR_get_memory_requirements2 +VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2KHR *pInfo, + VkMemoryRequirements2KHR *pMemoryRequirements) { + bool skip = VK_FALSE; + std::unique_lock lock(global_lock); + skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= + ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (!skip) { + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + dev_data->dispatch_table.GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } +} + +VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR *pInfo, + VkMemoryRequirements2KHR *pMemoryRequirements) { + bool skip = VK_FALSE; + std::unique_lock lock(global_lock); + skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, pInfo->buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); + lock.unlock(); if (!skip) { - get_dispatch_table(ot_instance_table_map, physicalDevice) - ->GetPhysicalDeviceExternalBufferPropertiesKHX(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + dev_data->dispatch_table.GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } } -// VK_KHX_external_memory_fd Extension -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHX(VkDevice device, VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, int *pFd) { - bool skip = false; +VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(VkDevice device, + const VkImageSparseMemoryRequirementsInfo2KHR *pInfo, + uint32_t *pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) { + bool skip = VK_FALSE; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_UNDEFINED, + skip |= + ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (!skip) { + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + dev_data->dispatch_table.GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, + pSparseMemoryRequirements); + } +} + +// VK_KHR_maintenance1 Extension +VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) { + bool skip = VK_FALSE; + std::unique_lock lock(global_lock); + skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); lock.unlock(); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; + if (!skip) { + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + dev_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags); } - VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->GetMemoryFdKHX(device, memory, handleType, pFd); - return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHX(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, - VkMemoryFdPropertiesKHX *pMemoryFdProperties) { +// VK_KHR_push_descriptor Extension +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet *pDescriptorWrites) { + bool skip = false; + std::unique_lock lock(global_lock); + skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (!skip) { + get_dispatch_table(ot_device_table_map, commandBuffer) + ->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); + } +} + +// VK_KHX_device_group Extension +VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlagsKHX *pPeerMemoryFeatures) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); lock.unlock(); - if (skip) { - return VK_ERROR_VALIDATION_FAILED_EXT; + if (!skip) { + get_dispatch_table(ot_device_table_map, device) + ->GetDeviceGroupPeerMemoryFeaturesKHX(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } - VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->GetMemoryFdPropertiesKHX(device, handleType, fd, pMemoryFdProperties); - return result; } -// VK_KHX_external_memory_win32 Extension -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHX(VkDevice device, VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE *pHandle) { +VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(VkDevice device, uint32_t bindInfoCount, + const VkBindBufferMemoryInfoKHX *pBindInfos) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_UNDEFINED, - VALIDATION_ERROR_UNDEFINED); lock.unlock(); if (skip) { return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->GetMemoryWin32HandleKHX(device, memory, handleType, pHandle); + result = get_dispatch_table(ot_device_table_map, device)->BindBufferMemory2KHX(device, bindInfoCount, pBindInfos); return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHX(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHX *pMemoryWin32HandleProperties) { +VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(VkDevice device, uint32_t bindInfoCount, + const VkBindImageMemoryInfoKHX *pBindInfos) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); @@ -4392,30 +4493,23 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHX(VkDevice device return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device) - ->GetMemoryWin32HandlePropertiesKHX(device, handleType, handle, pMemoryWin32HandleProperties); + result = get_dispatch_table(ot_device_table_map, device)->BindImageMemory2KHX(device, bindInfoCount, pBindInfos); return result; } -#endif // VK_USE_PLATFORM_WIN32_KHX -// VK_KHX_external_semaphore_capabilities Extension -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHX( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX *pExternalSemaphoreInfo, - VkExternalSemaphorePropertiesKHX *pExternalSemaphoreProperties) { +VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(VkCommandBuffer commandBuffer, uint32_t deviceMask) { bool skip = false; - { std::unique_lock lock(global_lock); - skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_UNDEFINED, + skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); - } + lock.unlock(); if (!skip) { - get_dispatch_table(ot_instance_table_map, physicalDevice) - ->GetPhysicalDeviceExternalSemaphorePropertiesKHX(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetDeviceMaskKHX(commandBuffer, deviceMask); } } -// VK_KHX_external_semaphore_fd Extension -VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHX(VkDevice device, const VkImportSemaphoreFdInfoKHX *pImportSemaphoreFdInfo) { +VKAPI_ATTR VkResult VKAPI_CALL +GetDeviceGroupPresentCapabilitiesKHX(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX *pDeviceGroupPresentCapabilities) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); @@ -4424,12 +4518,13 @@ VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHX(VkDevice device, const VkImp return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->ImportSemaphoreFdKHX(device, pImportSemaphoreFdInfo); + result = get_dispatch_table(ot_device_table_map, device) + ->GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities); return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHX(VkDevice device, VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int *pFd) { +VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(VkDevice device, VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHX *pModes) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); @@ -4438,14 +4533,12 @@ VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHX(VkDevice device, VkSemaphore se return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->GetSemaphoreFdKHX(device, semaphore, handleType, pFd); + result = get_dispatch_table(ot_device_table_map, device)->GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes); return result; } -// VK_KHX_external_semaphore_win32 Extension -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL -ImportSemaphoreWin32HandleKHX(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX *pImportSemaphoreWin32HandleInfo) { +VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(VkDevice device, const VkAcquireNextImageInfoKHX *pAcquireInfo, + uint32_t *pImageIndex) { bool skip = false; std::unique_lock lock(global_lock); skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); @@ -4454,25 +4547,68 @@ ImportSemaphoreWin32HandleKHX(VkDevice device, const VkImportSemaphoreWin32Handl return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = VK_SUCCESS; - result = - get_dispatch_table(ot_device_table_map, device)->ImportSemaphoreWin32HandleKHX(device, pImportSemaphoreWin32HandleInfo); + result = get_dispatch_table(ot_device_table_map, device)->AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex); return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHX(VkDevice device, VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE *pHandle) { +VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, + uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ) { bool skip = false; std::unique_lock lock(global_lock); - skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); + lock.unlock(); + if (!skip) { + get_dispatch_table(ot_device_table_map, commandBuffer) + ->CmdDispatchBaseKHX(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t *pRectCount, VkRect2D *pRects) { + bool skip = false; + { + std::unique_lock lock(global_lock); + skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); + } + if (!skip) { + get_dispatch_table(ot_instance_table_map, physicalDevice) + ->GetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, pRectCount, pRects); + } +} + +// VK_KHX_device_group_creation Extension +VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX( + VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) { + bool skip = false; + std::unique_lock lock(global_lock); + skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_UNDEFINED, + VALIDATION_ERROR_UNDEFINED); lock.unlock(); if (skip) { return VK_ERROR_VALIDATION_FAILED_EXT; } - VkResult result = VK_SUCCESS; - result = get_dispatch_table(ot_device_table_map, device)->GetSemaphoreWin32HandleKHX(device, semaphore, handleType, pHandle); + VkResult result = get_dispatch_table(ot_instance_table_map, instance) + ->EnumeratePhysicalDeviceGroupsKHX(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + { + lock.lock(); + if (result == VK_SUCCESS) { + if (nullptr != pPhysicalDeviceGroupProperties) { + // NOTE: Each physical device should only appear in one group + for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) { + for (uint32_t j = 0; j < pPhysicalDeviceGroupProperties[i].physicalDeviceCount; j++) { + CreateObject(instance, pPhysicalDeviceGroupProperties[i].physicalDevices[j], + kVulkanObjectTypePhysicalDevice, nullptr); + } + } + } + } + lock.unlock(); + } return result; } -#endif // VK_USE_PLATFORM_WIN32_KHX // VK_EXT_acquire_xlib_display Extension #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT @@ -5030,6 +5166,8 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDev std::lock_guard lock(global_lock); skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e827a01, VALIDATION_ERROR_UNDEFINED); + skip |= ValidateObject(physicalDevice, pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, + VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); } if (skip) { return VK_ERROR_VALIDATION_FAILED_EXT; @@ -5194,8 +5332,8 @@ static const std::unordered_map name_to_funcptr_map = { {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void*)GetPhysicalDeviceQueueFamilyProperties2KHR}, {"vkGetPhysicalDevicePresentRectanglesKHX", (void*)GetPhysicalDevicePresentRectanglesKHX}, {"vkEnumeratePhysicalDeviceGroupsKHX", (void*)EnumeratePhysicalDeviceGroupsKHX}, - {"vkGetPhysicalDeviceExternalBufferPropertiesKHX", (void*)GetPhysicalDeviceExternalBufferPropertiesKHX}, - {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHX", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHX}, + {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (void*)GetPhysicalDeviceExternalBufferPropertiesKHR}, + {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR}, {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT}, {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT}, {"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV}, @@ -5214,10 +5352,10 @@ static const std::unordered_map name_to_funcptr_map = { {"vkGetDeviceGroupSurfacePresentModesKHX", (void*)GetDeviceGroupSurfacePresentModesKHX}, {"vkAcquireNextImage2KHX", (void*)AcquireNextImage2KHX}, {"vkCmdDispatchBaseKHX", (void*)CmdDispatchBaseKHX}, - {"vkGetMemoryFdKHX", (void*)GetMemoryFdKHX}, - {"vkGetMemoryFdPropertiesKHX", (void*)GetMemoryFdPropertiesKHX}, - {"vkImportSemaphoreFdKHX", (void*)ImportSemaphoreFdKHX}, - {"vkGetSemaphoreFdKHX", (void*)GetSemaphoreFdKHX}, + {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR}, + {"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR}, + {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR}, + {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR}, {"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT}, {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT}, {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT}, @@ -5255,20 +5393,25 @@ static const std::unordered_map name_to_funcptr_map = { {"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT}, {"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT}, {"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT}, + {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (void*)GetPhysicalDeviceExternalFencePropertiesKHR}, + {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR}, + {"vkGetFenceFdKHR", (void*)GetFenceFdKHR}, + {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR}, + {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR}, #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT}, {"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT}, #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT -#ifdef VK_USE_PLATFORM_WIN32_KHX - {"vkGetMemoryWin32HandleKHX", (void*)GetMemoryWin32HandleKHX}, - {"vkGetMemoryWin32HandlePropertiesKHX", (void*)GetMemoryWin32HandlePropertiesKHX}, - {"vkImportSemaphoreWin32HandleKHX", (void*)ImportSemaphoreWin32HandleKHX}, - {"vkGetSemaphoreWin32HandleKHX", (void*)GetSemaphoreWin32HandleKHX}, -#endif #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR}, {"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void*)GetPhysicalDeviceWin32PresentationSupportKHR}, {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV}, + {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR}, + {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR}, + {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR}, + {"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR}, + {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR}, + {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR}, #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_XCB_KHR {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR}, diff --git a/layers/parameter_validation.cpp b/layers/parameter_validation.cpp index c933a595..e5a12941 100644 --- a/layers/parameter_validation.cpp +++ b/layers/parameter_validation.cpp @@ -4665,6 +4665,115 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, return result; } +// Definitions for the VK_KHR_descriptor_update_template extension + +VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device, + const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkCreateDescriptorUpdateTemplateKHR(my_data, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + + if (!skip) { + result = + my_data->dispatch_table.CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + validate_result(my_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", {}, result); + } + + return result; +} + +VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const VkAllocationCallbacks *pAllocator) { + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkDestroyDescriptorUpdateTemplateKHR(my_data, descriptorUpdateTemplate, pAllocator); + + if (!skip) { + my_data->dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); + } +} + +VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const void *pData) { + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkUpdateDescriptorSetWithTemplateKHR(my_data, descriptorSet, descriptorUpdateTemplate, pData); + + if (!skip) { + my_data->dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); + } +} + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + VkPipelineLayout layout, uint32_t set, const void *pData) { + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkCmdPushDescriptorSetWithTemplateKHR(my_data, descriptorUpdateTemplate, layout, set, pData); + + if (!skip) { + my_data->dispatch_table.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + } +} + +VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { + bool skip = false; + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + + skip = parameter_validation_vkGetSwapchainStatusKHR(dev_data, swapchain); + + if (!skip) { + result = dev_data->dispatch_table.GetSwapchainStatusKHR(device, swapchain); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, + VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { + bool skip = false; + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + + skip = parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance_data, pSurfaceInfo, pSurfaceCapabilities); + + if (!skip) { + result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, + pSurfaceCapabilities); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, + uint32_t *pSurfaceFormatCount, + VkSurfaceFormat2KHR *pSurfaceFormats) { + bool skip = false; + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + skip = parameter_validation_vkGetPhysicalDeviceSurfaceFormats2KHR(instance_data, pSurfaceInfo, pSurfaceFormatCount, + pSurfaceFormats); + if (!skip) { + result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, + pSurfaceFormatCount, pSurfaceFormats); + } + return result; +} + // Definitions for the VK_KHR_get_physical_device_properties2 extension VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) { @@ -4794,493 +4903,511 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( } } -// Definitions for the VK_KHR_maintenance1 extension +// Definitions for the VK_KHR_external_fence_capabilities extension -VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) { +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR *pExternalFenceInfo, + VkExternalFencePropertiesKHR *pExternalFenceProperties) { + auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + bool skip = false; + skip |= + parameter_validation_vkGetPhysicalDeviceExternalFencePropertiesKHR(my_data, pExternalFenceInfo, pExternalFenceProperties); + if (!skip) { + my_data->dispatch_table.GetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, + pExternalFenceProperties); + } +} + +// Definitions for the VK_KHR_external_fence_fd extension + +VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkTrimCommandPoolKHR(my_data, commandPool, flags); + skip |= parameter_validation_vkImportFenceFdKHR(my_data, pImportFenceFdInfo); if (!skip) { - my_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags); + result = my_data->dispatch_table.ImportFenceFdKHR(device, pImportFenceFdInfo); + validate_result(my_data->report_data, "vkImportFenceFdKHR", {}, result); } -} -// Definitions for the VK_KHR_push_descriptor extension + return result; +} -VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites) { +VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdPushDescriptorSetKHR(my_data, pipelineBindPoint, layout, set, - descriptorWriteCount, pDescriptorWrites); + skip |= parameter_validation_vkGetFenceFdKHR(my_data, pGetFdInfo, pFd); if (!skip) { - my_data->dispatch_table.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, - pDescriptorWrites); + result = my_data->dispatch_table.GetFenceFdKHR(device, pGetFdInfo, pFd); + validate_result(my_data->report_data, "vkGetFenceFdKHR", {}, result); } + + return result; } -// Definitions for the VK_KHR_descriptor_update_template extension +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Definitions for the VK_KHR_external_fence_win32 extension -VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device, - const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { +VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(VkDevice device, + const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateDescriptorUpdateTemplateKHR(my_data, pCreateInfo, pAllocator, - pDescriptorUpdateTemplate); + skip |= parameter_validation_vkImportFenceWin32HandleKHR(my_data, pImportFenceWin32HandleInfo); if (!skip) { - result = - my_data->dispatch_table.CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); - validate_result(my_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", {}, result); + result = my_data->dispatch_table.ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); + validate_result(my_data->report_data, "vkImportFenceWin32HandleKHR", {}, result); } return result; } -VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const VkAllocationCallbacks *pAllocator) { +VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, + HANDLE *pHandle) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyDescriptorUpdateTemplateKHR(my_data, descriptorUpdateTemplate, pAllocator); + skip |= parameter_validation_vkGetFenceWin32HandleKHR(my_data, pGetWin32HandleInfo, pHandle); if (!skip) { - my_data->dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); + result = my_data->dispatch_table.GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + validate_result(my_data->report_data, "vkGetFenceWin32HandleKHR", {}, result); } + + return result; } +#endif // VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const void *pData) { +// Definitions for the VK_KHR_external_memory_capabilities extension + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo, + VkExternalBufferPropertiesKHR *pExternalBufferProperties) { + auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + bool skip = false; + skip |= parameter_validation_vkGetPhysicalDeviceExternalBufferPropertiesKHR(my_data, pExternalBufferInfo, + pExternalBufferProperties); + if (!skip) { + my_data->dispatch_table.GetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, + pExternalBufferProperties); + } +} + +// Definitions for the VK_KHR_external_memory_fd extension + +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int *pFd) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkUpdateDescriptorSetWithTemplateKHR(my_data, descriptorSet, descriptorUpdateTemplate, - pData); + skip |= parameter_validation_vkGetMemoryFdKHR(my_data, pGetFdInfo, pFd); if (!skip) { - my_data->dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); + result = my_data->dispatch_table.GetMemoryFdKHR(device, pGetFdInfo, pFd); + validate_result(my_data->report_data, "vkGetMemoryFdKHR", {}, result); } + + return result; } -VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - VkPipelineLayout layout, uint32_t set, const void *pData) { +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, + VkMemoryFdPropertiesKHR *pMemoryFdProperties) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdPushDescriptorSetWithTemplateKHR(my_data, descriptorUpdateTemplate, layout, set, - pData); + skip |= parameter_validation_vkGetMemoryFdPropertiesKHR(my_data, handleType, fd, pMemoryFdProperties); if (!skip) { - my_data->dispatch_table.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + result = my_data->dispatch_table.GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); + validate_result(my_data->report_data, "vkGetMemoryFdPropertiesKHR", {}, result); } + + return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); +// Definitions for the VK_KHR_external_memory_win32 extension + +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, + HANDLE *pHandle) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); - skip = parameter_validation_vkGetSwapchainStatusKHR(dev_data, swapchain); + skip |= parameter_validation_vkGetMemoryWin32HandleKHR(my_data, pGetWin32HandleInfo, pHandle); if (!skip) { - result = dev_data->dispatch_table.GetSwapchainStatusKHR(device, swapchain); + result = my_data->dispatch_table.GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + validate_result(my_data->report_data, "vkGetMemoryWin32HandleKHR", {}, result); } return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); - skip = parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance_data, pSurfaceInfo, - pSurfaceCapabilities); + skip |= parameter_validation_vkGetMemoryWin32HandlePropertiesKHR(my_data, handleType, handle, pMemoryWin32HandleProperties); if (!skip) { - result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, - pSurfaceCapabilities); + result = + my_data->dispatch_table.GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); + validate_result(my_data->report_data, "vkGetMemoryWin32HandlePropertiesKHR", {}, result); } return result; } +#endif // VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - uint32_t *pSurfaceFormatCount, - VkSurfaceFormat2KHR *pSurfaceFormats) { +// Definitions for the VK_KHR_external_semaphore_capabilities extension + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR *pExternalSemaphoreProperties) { + auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - skip = parameter_validation_vkGetPhysicalDeviceSurfaceFormats2KHR(instance_data, pSurfaceInfo, pSurfaceFormatCount, - pSurfaceFormats); + skip |= parameter_validation_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(my_data, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); if (!skip) { - result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, - pSurfaceFormatCount, pSurfaceFormats); + my_data->dispatch_table.GetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); } - return result; } -// Definitions for the VK_KHX_device_group_creation extension +// Definitions for the VK_KHR_external_semaphore_fd extension -VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX( - VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) { +VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkEnumeratePhysicalDeviceGroupsKHX(my_data, pPhysicalDeviceGroupCount, - pPhysicalDeviceGroupProperties); + skip |= parameter_validation_vkImportSemaphoreFdKHR(my_data, pImportSemaphoreFdInfo); if (!skip) { - result = my_data->dispatch_table.EnumeratePhysicalDeviceGroupsKHX(instance, pPhysicalDeviceGroupCount, - pPhysicalDeviceGroupProperties); - validate_result(my_data->report_data, "vkEnumeratePhysicalDeviceGroupsKHX", {}, result); + result = my_data->dispatch_table.ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); + validate_result(my_data->report_data, "vkImportSemaphoreFdKHR", {}, result); } + return result; } -// Definitions for the VK_KHX_device_group extension - -VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlagsKHX *pPeerMemoryFeatures) { +VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int *pFd) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetDeviceGroupPeerMemoryFeaturesKHX(my_data, heapIndex, localDeviceIndex, - remoteDeviceIndex, pPeerMemoryFeatures); + skip |= parameter_validation_vkGetSemaphoreFdKHR(my_data, pGetFdInfo, pFd); if (!skip) { - my_data->dispatch_table.GetDeviceGroupPeerMemoryFeaturesKHX(device, heapIndex, localDeviceIndex, remoteDeviceIndex, - pPeerMemoryFeatures); + result = my_data->dispatch_table.GetSemaphoreFdKHR(device, pGetFdInfo, pFd); + validate_result(my_data->report_data, "vkGetSemaphoreFdKHR", {}, result); } + + return result; } -VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(VkDevice device, uint32_t bindInfoCount, - const VkBindBufferMemoryInfoKHX *pBindInfos) { +// Definitions for the VK_KHR_external_semaphore_win32 extension + +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL +ImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkBindBufferMemory2KHX(my_data, bindInfoCount, pBindInfos); - + skip |= parameter_validation_vkImportSemaphoreWin32HandleKHR(my_data, pImportSemaphoreWin32HandleInfo); if (!skip) { - result = my_data->dispatch_table.BindBufferMemory2KHX(device, bindInfoCount, pBindInfos); - validate_result(my_data->report_data, "vkBindBufferMemory2KHX", {}, result); + result = my_data->dispatch_table.ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); + validate_result(my_data->report_data, "vkImportSemaphoreWin32HandleKHR", {}, result); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(VkDevice device, uint32_t bindInfoCount, - const VkBindImageMemoryInfoKHX *pBindInfos) { +VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, + HANDLE *pHandle) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkBindImageMemory2KHX(my_data, bindInfoCount, pBindInfos); - + skip |= parameter_validation_vkGetSemaphoreWin32HandleKHR(my_data, pGetWin32HandleInfo, pHandle); if (!skip) { - result = my_data->dispatch_table.BindImageMemory2KHX(device, bindInfoCount, pBindInfos); - validate_result(my_data->report_data, "vkBindImageMemory2KHX", {}, result); + result = my_data->dispatch_table.GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + validate_result(my_data->report_data, "vkGetSemaphoreWin32HandleKHR", {}, result); } - return result; } +#endif // VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(VkCommandBuffer commandBuffer, uint32_t deviceMask) { +// Definitions for the VK_KHR_get_memory_requirements2 extension + +VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2KHR *pInfo, + VkMemoryRequirements2KHR *pMemoryRequirements) { bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdSetDeviceMaskKHX(my_data, deviceMask); + skip |= parameter_validation_vkGetImageMemoryRequirements2KHR(my_data, pInfo, pMemoryRequirements); if (!skip) { - my_data->dispatch_table.CmdSetDeviceMaskKHX(commandBuffer, deviceMask); + my_data->dispatch_table.GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } } -VKAPI_ATTR VkResult VKAPI_CALL -GetDeviceGroupPresentCapabilitiesKHX(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX *pDeviceGroupPresentCapabilities) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR *pInfo, + VkMemoryRequirements2KHR *pMemoryRequirements) { bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetDeviceGroupPresentCapabilitiesKHX(my_data, pDeviceGroupPresentCapabilities); + skip |= parameter_validation_vkGetBufferMemoryRequirements2KHR(my_data, pInfo, pMemoryRequirements); if (!skip) { - result = my_data->dispatch_table.GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities); - validate_result(my_data->report_data, "vkGetDeviceGroupPresentCapabilitiesKHX", {}, result); + my_data->dispatch_table.GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } - - return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(VkDevice device, VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHX *pModes) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(VkDevice device, + const VkImageSparseMemoryRequirementsInfo2KHR *pInfo, + uint32_t *pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) { bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetDeviceGroupSurfacePresentModesKHX(my_data, surface, pModes); + skip |= parameter_validation_vkGetImageSparseMemoryRequirements2KHR(my_data, pInfo, pSparseMemoryRequirementCount, + pSparseMemoryRequirements); if (!skip) { - result = my_data->dispatch_table.GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes); - validate_result(my_data->report_data, "vkGetDeviceGroupSurfacePresentModesKHX", {}, result); + my_data->dispatch_table.GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, + pSparseMemoryRequirements); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(VkDevice device, const VkAcquireNextImageInfoKHX *pAcquireInfo, - uint32_t *pImageIndex) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +// Definitions for the VK_KHR_maintenance1 extension + +VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) { bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkAcquireNextImage2KHX(my_data, pAcquireInfo, pImageIndex); + skip |= parameter_validation_vkTrimCommandPoolKHR(my_data, commandPool, flags); if (!skip) { - result = my_data->dispatch_table.AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex); - validate_result(my_data->report_data, "vkAcquireNextImage2KHX", {}, result); + my_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags); } - return result; } -VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, - uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, - uint32_t groupCountZ) { +// Definitions for the VK_KHR_push_descriptor extension + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet *pDescriptorWrites) { bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdDispatchBaseKHX(my_data, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, - groupCountZ); + skip |= parameter_validation_vkCmdPushDescriptorSetKHR(my_data, pipelineBindPoint, layout, set, descriptorWriteCount, + pDescriptorWrites); if (!skip) { - my_data->dispatch_table.CmdDispatchBaseKHX(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, - groupCountZ); + my_data->dispatch_table.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, + pDescriptorWrites); } } -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - uint32_t *pRectCount, VkRect2D *pRects) { +// Definitions for the VK_KHX_device_group_creation extension + +VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX( + VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDevicePresentRectanglesKHX(my_data, surface, pRectCount, pRects); + skip |= parameter_validation_vkEnumeratePhysicalDeviceGroupsKHX(my_data, pPhysicalDeviceGroupCount, + pPhysicalDeviceGroupProperties); if (!skip) { - result = my_data->dispatch_table.GetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, pRectCount, pRects); - - validate_result(my_data->report_data, "vkGetPhysicalDevicePresentRectanglesKHX", {}, result); + result = my_data->dispatch_table.EnumeratePhysicalDeviceGroupsKHX(instance, pPhysicalDeviceGroupCount, + pPhysicalDeviceGroupProperties); + validate_result(my_data->report_data, "vkEnumeratePhysicalDeviceGroupsKHX", {}, result); } - return result; } -// Definitions for the VK_KHX_external_memory_capabilities extension +// Definitions for the VK_KHX_device_group extension -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHX( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX *pExternalBufferInfo, - VkExternalBufferPropertiesKHX *pExternalBufferProperties) { - auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - assert(my_data != NULL); +VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlagsKHX *pPeerMemoryFeatures) { bool skip = false; - skip |= parameter_validation_vkGetPhysicalDeviceExternalBufferPropertiesKHX(my_data, pExternalBufferInfo, - pExternalBufferProperties); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkGetDeviceGroupPeerMemoryFeaturesKHX(my_data, heapIndex, localDeviceIndex, + remoteDeviceIndex, pPeerMemoryFeatures); + if (!skip) { - my_data->dispatch_table.GetPhysicalDeviceExternalBufferPropertiesKHX(physicalDevice, pExternalBufferInfo, - pExternalBufferProperties); + my_data->dispatch_table.GetDeviceGroupPeerMemoryFeaturesKHX(device, heapIndex, localDeviceIndex, remoteDeviceIndex, + pPeerMemoryFeatures); } } -// Definitions for the VK_KHX_external_memory_fd extension - -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHX(VkDevice device, VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, int *pFd) { +VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(VkDevice device, uint32_t bindInfoCount, + const VkBindBufferMemoryInfoKHX *pBindInfos) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetMemoryFdKHX(my_data, memory, handleType, pFd); + skip |= parameter_validation_vkBindBufferMemory2KHX(my_data, bindInfoCount, pBindInfos); if (!skip) { - result = my_data->dispatch_table.GetMemoryFdKHX(device, memory, handleType, pFd); - validate_result(my_data->report_data, "vkGetMemoryFdKHX", {}, result); + result = my_data->dispatch_table.BindBufferMemory2KHX(device, bindInfoCount, pBindInfos); + validate_result(my_data->report_data, "vkBindBufferMemory2KHX", {}, result); } return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHX(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, - VkMemoryFdPropertiesKHX *pMemoryFdProperties) { +VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(VkDevice device, uint32_t bindInfoCount, + const VkBindImageMemoryInfoKHX *pBindInfos) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetMemoryFdPropertiesKHX(my_data, handleType, fd, pMemoryFdProperties); + skip |= parameter_validation_vkBindImageMemory2KHX(my_data, bindInfoCount, pBindInfos); if (!skip) { - result = my_data->dispatch_table.GetMemoryFdPropertiesKHX(device, handleType, fd, pMemoryFdProperties); - validate_result(my_data->report_data, "vkGetMemoryFdPropertiesKHX", {}, result); + result = my_data->dispatch_table.BindImageMemory2KHX(device, bindInfoCount, pBindInfos); + validate_result(my_data->report_data, "vkBindImageMemory2KHX", {}, result); } return result; } -// Definitions for the VK_KHX_external_memory_win32 extension - -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHX(VkDevice device, VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE *pHandle) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(VkCommandBuffer commandBuffer, uint32_t deviceMask) { bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetMemoryWin32HandleKHX(my_data, memory, handleType, pHandle); + skip |= parameter_validation_vkCmdSetDeviceMaskKHX(my_data, deviceMask); if (!skip) { - result = my_data->dispatch_table.GetMemoryWin32HandleKHX(device, memory, handleType, pHandle); - validate_result(my_data->report_data, "vkGetMemoryWin32HandleKHX", {}, result); + my_data->dispatch_table.CmdSetDeviceMaskKHX(commandBuffer, deviceMask); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHX(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHX *pMemoryWin32HandleProperties) { +VKAPI_ATTR VkResult VKAPI_CALL +GetDeviceGroupPresentCapabilitiesKHX(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX *pDeviceGroupPresentCapabilities) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetMemoryWin32HandlePropertiesKHX(my_data, handleType, handle, - pMemoryWin32HandleProperties); + skip |= parameter_validation_vkGetDeviceGroupPresentCapabilitiesKHX(my_data, pDeviceGroupPresentCapabilities); if (!skip) { - result = - my_data->dispatch_table.GetMemoryWin32HandlePropertiesKHX(device, handleType, handle, pMemoryWin32HandleProperties); - validate_result(my_data->report_data, "vkGetMemoryWin32HandlePropertiesKHX", {}, result); + result = my_data->dispatch_table.GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities); + validate_result(my_data->report_data, "vkGetDeviceGroupPresentCapabilitiesKHX", {}, result); } - return result; -} -#endif // VK_USE_PLATFORM_WIN32_KHX - -// Definitions for the VK_KHX_external_semaphore_capabilities extension -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHX( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX *pExternalSemaphoreInfo, - VkExternalSemaphorePropertiesKHX *pExternalSemaphoreProperties) { - auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - assert(my_data != NULL); - bool skip = false; - skip |= parameter_validation_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(my_data, pExternalSemaphoreInfo, - pExternalSemaphoreProperties); - if (!skip) { - my_data->dispatch_table.GetPhysicalDeviceExternalSemaphorePropertiesKHX(physicalDevice, pExternalSemaphoreInfo, - pExternalSemaphoreProperties); - } + return result; } -// Definitions for the VK_KHX_external_semaphore_fd extension - -VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHX(VkDevice device, const VkImportSemaphoreFdInfoKHX *pImportSemaphoreFdInfo) { +VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(VkDevice device, VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHX *pModes) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkImportSemaphoreFdKHX(my_data, pImportSemaphoreFdInfo); + skip |= parameter_validation_vkGetDeviceGroupSurfacePresentModesKHX(my_data, surface, pModes); if (!skip) { - result = my_data->dispatch_table.ImportSemaphoreFdKHX(device, pImportSemaphoreFdInfo); - validate_result(my_data->report_data, "vkImportSemaphoreFdKHX", {}, result); + result = my_data->dispatch_table.GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes); + validate_result(my_data->report_data, "vkGetDeviceGroupSurfacePresentModesKHX", {}, result); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHX(VkDevice device, VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int *pFd) { +VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(VkDevice device, const VkAcquireNextImageInfoKHX *pAcquireInfo, + uint32_t *pImageIndex) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetSemaphoreFdKHX(my_data, semaphore, handleType, pFd); + skip |= parameter_validation_vkAcquireNextImage2KHX(my_data, pAcquireInfo, pImageIndex); if (!skip) { - result = my_data->dispatch_table.GetSemaphoreFdKHX(device, semaphore, handleType, pFd); - validate_result(my_data->report_data, "vkGetSemaphoreFdKHX", {}, result); + result = my_data->dispatch_table.AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex); + validate_result(my_data->report_data, "vkAcquireNextImage2KHX", {}, result); } - return result; } -// Definitions for the VK_KHX_external_semaphore_win32 extension - -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL -ImportSemaphoreWin32HandleKHX(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX *pImportSemaphoreWin32HandleInfo) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, + uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ) { bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkImportSemaphoreWin32HandleKHX(my_data, pImportSemaphoreWin32HandleInfo); + skip |= parameter_validation_vkCmdDispatchBaseKHX(my_data, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, + groupCountZ); + if (!skip) { - result = my_data->dispatch_table.ImportSemaphoreWin32HandleKHX(device, pImportSemaphoreWin32HandleInfo); - validate_result(my_data->report_data, "vkImportSemaphoreWin32HandleKHX", {}, result); + my_data->dispatch_table.CmdDispatchBaseKHX(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, + groupCountZ); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHX(VkDevice device, VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE *pHandle) { +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t *pRectCount, VkRect2D *pRects) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetSemaphoreWin32HandleKHX(my_data, semaphore, handleType, pHandle); + skip |= parameter_validation_vkGetPhysicalDevicePresentRectanglesKHX(my_data, surface, pRectCount, pRects); + if (!skip) { - result = my_data->dispatch_table.GetSemaphoreWin32HandleKHX(device, semaphore, handleType, pHandle); - validate_result(my_data->report_data, "vkGetSemaphoreWin32HandleKHX", {}, result); + result = my_data->dispatch_table.GetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, pRectCount, pRects); + + validate_result(my_data->report_data, "vkGetPhysicalDevicePresentRectanglesKHX", {}, result); } + return result; } -#endif // VK_USE_PLATFORM_WIN32_KHX // Definitions for the VK_EXT_acquire_xlib_display extension diff --git a/layers/vk_validation_error_database.txt b/layers/vk_validation_error_database.txt index f42f916c..39bb9fb1 100644 --- a/layers/vk_validation_error_database.txt +++ b/layers/vk_validation_error_database.txt @@ -93,13 +93,14 @@ VALIDATION_ERROR_01400726~^~Y~^~None~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo- VALIDATION_ERROR_01400728~^~Y~^~None~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-flags-00916~^~core~^~The spec valid usage text states 'If the sparse buffer residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00916)~^~ VALIDATION_ERROR_0140072a~^~Y~^~None~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-flags-00917~^~core~^~The spec valid usage text states 'If the sparse aliased residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00917)~^~ VALIDATION_ERROR_0140072c~^~Y~^~SparseBindingImageBufferCreate~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-flags-00918~^~core~^~The spec valid usage text states 'If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00918)~^~ -VALIDATION_ERROR_0140072e~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-handleTypes-00919~^~(VK_KHX_external_memory+VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If any of the handle types specified in VkExternalMemoryImageCreateInfoKHX::handleTypes requires dedicated allocation, as reported by vkGetPhysicalDeviceExternalBufferPropertiesKHX in VkExternalBufferPropertiesKHX::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationBufferCreateInfoNV with its dedicatedAllocation field set to VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-handleTypes-00919)~^~ -VALIDATION_ERROR_01400730~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-pNext-00920~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If the pNext extension contains an instance of VkExternalMemoryBufferCreateInfoKHX, its handleTypes member must only contain bits that are also in VkExternalBufferPropertiesKHX::externalMemoryProperties.pname:compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferPropertiesKHX with pExternalBufferInfo->handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfoKHX::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-00920)~^~ +VALIDATION_ERROR_0140072e~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-handleTypes-00919~^~core~^~The spec valid usage text states 'If any of the handle types specified in VkExternalMemoryImageCreateInfoKHR::handleTypes requires dedicated allocation, as reported by vkGetPhysicalDeviceExternalBufferPropertiesKHR in VkExternalBufferPropertiesKHR::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationBufferCreateInfoNV with its dedicatedAllocation field set to VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-handleTypes-00919)~^~ +VALIDATION_ERROR_01400730~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-pNext-00920~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryBufferCreateInfoKHR, its handleTypes member must only contain bits that are also in VkExternalBufferPropertiesKHR::externalMemoryProperties.pname:compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferPropertiesKHR with pExternalBufferInfo->handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfoKHR::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-00920)~^~ VALIDATION_ERROR_01400ade~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sharingMode-01391~^~!(VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-01391)~^~ VALIDATION_ERROR_01400b16~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sharingMode-01419~^~(VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2KHR for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-01419)~^~ VALIDATION_ERROR_01409001~^~Y~^~None~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkBufferCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0141c40d~^~Y~^~Unknown~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDedicatedAllocationBufferCreateInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-pNext)~^~implicit +VALIDATION_ERROR_0141c40d~^~Y~^~Unknown~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationBufferCreateInfoNV or VkExternalMemoryBufferCreateInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-pNext)~^~implicit VALIDATION_ERROR_0142b00b~^~Y~^~None~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. +VALIDATION_ERROR_0142b00f~^~N~^~None~^~VkBufferCreateInfo~^~VUID-VkBufferCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sType-unique)~^~implicit VALIDATION_ERROR_0142c001~^~Y~^~None~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-sharingMode-parameter~^~core~^~The spec valid usage text states 'sharingMode must be a valid VkSharingMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-parameter)~^~implicit VALIDATION_ERROR_01430601~^~N~^~None~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-usage-parameter~^~core~^~The spec valid usage text states 'usage must be a valid combination of VkBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-usage-parameter)~^~implicit VALIDATION_ERROR_01430603~^~Y~^~None~^~vkCreateBuffer~^~VUID-VkBufferCreateInfo-usage-requiredbitmask~^~core~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-usage-requiredbitmask)~^~implicit @@ -128,14 +129,14 @@ VALIDATION_ERROR_0160aa01~^~N~^~Unknown~^~vkCmdCopyImageToBuffer~^~VUID-VkBuffer VALIDATION_ERROR_01800946~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-offset-01187~^~core~^~The spec valid usage text states 'offset must be less than the size of buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-offset-01187)~^~ VALIDATION_ERROR_01800948~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-size-01188~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-size-01188)~^~ VALIDATION_ERROR_0180094a~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-size-01189~^~core~^~The spec valid usage text states 'If size is not equal to VK_WHOLE_SIZE, size must be less than or equal to than the size of buffer minus offset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-size-01189)~^~ -VALIDATION_ERROR_0180094c~^~N~^~None~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01190~^~!(VK_KHX_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01190)~^~ -VALIDATION_ERROR_0180094e~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01191~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01191)~^~ -VALIDATION_ERROR_01800950~^~N~^~None~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01192~^~!(VK_KHX_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01192)~^~ -VALIDATION_ERROR_01800952~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01193~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01193)~^~ -VALIDATION_ERROR_01800954~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01194~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHX (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01194)~^~ -VALIDATION_ERROR_01800956~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01195~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHX (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01195)~^~ +VALIDATION_ERROR_0180094c~^~N~^~None~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01190~^~!(VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01190)~^~ +VALIDATION_ERROR_0180094e~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01191~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01191)~^~ +VALIDATION_ERROR_01800950~^~N~^~None~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01192~^~!(VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01192)~^~ +VALIDATION_ERROR_01800952~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01193~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01193)~^~ +VALIDATION_ERROR_01800954~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01194~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHR (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01194)~^~ +VALIDATION_ERROR_01800956~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01195~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHR (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01195)~^~ VALIDATION_ERROR_01800958~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01196~^~core~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01196)~^~ -VALIDATION_ERROR_01800ac8~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01380~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or VK_QUEUE_FAMILY_EXTERNAL_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01380)~^~ +VALIDATION_ERROR_01800ac8~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-01380~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or VK_QUEUE_FAMILY_EXTERNAL_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01380)~^~ VALIDATION_ERROR_01801a01~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-buffer-parameter~^~core~^~The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-parameter)~^~implicit VALIDATION_ERROR_01806801~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-dstAccessMask-parameter~^~core~^~The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-dstAccessMask-parameter)~^~implicit VALIDATION_ERROR_0181c40d~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkBufferMemoryBarrier-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-pNext-pNext)~^~implicit, TBD in parameter validation layer. @@ -237,11 +238,11 @@ VALIDATION_ERROR_03207601~^~Y~^~None~^~vkUpdateDescriptorSets~^~VUID-VkCopyDescr VALIDATION_ERROR_0321c40d~^~Y~^~Unknown~^~vkUpdateDescriptorSets~^~VUID-VkCopyDescriptorSet-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-pNext-pNext)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_0322b00b~^~N~^~Unknown~^~vkUpdateDescriptorSets~^~VUID-VkCopyDescriptorSet-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-sType-sType)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_0322d201~^~Y~^~None~^~vkUpdateDescriptorSets~^~VUID-VkCopyDescriptorSet-srcSet-parameter~^~core~^~The spec valid usage text states 'srcSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-parameter)~^~implicit -VALIDATION_ERROR_0340009e~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHX-waitSemaphoreValuesCount-00079~^~core~^~The spec valid usage text states 'waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where SubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHX structure.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-waitSemaphoreValuesCount-00079)~^~ -VALIDATION_ERROR_034000a0~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHX-signalSemaphoreValuesCount-00080~^~core~^~The spec valid usage text states 'signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where SubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHX structure.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-signalSemaphoreValuesCount-00080)~^~ -VALIDATION_ERROR_03423201~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHX-pSignalSemaphoreValues-parameter~^~core~^~The spec valid usage text states 'If signalSemaphoreValuesCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a pointer to an array of signalSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-pSignalSemaphoreValues-parameter)~^~implicit -VALIDATION_ERROR_03427401~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHX-pWaitSemaphoreValues-parameter~^~core~^~The spec valid usage text states 'If waitSemaphoreValuesCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a pointer to an array of waitSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-pWaitSemaphoreValues-parameter)~^~implicit -VALIDATION_ERROR_0342b00b~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-sType-sType)~^~implicit +VALIDATION_ERROR_0340009e~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079~^~core~^~The spec valid usage text states 'waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079)~^~ +VALIDATION_ERROR_034000a0~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080~^~core~^~The spec valid usage text states 'signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080)~^~ +VALIDATION_ERROR_03423201~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter~^~core~^~The spec valid usage text states 'If signalSemaphoreValuesCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a pointer to an array of signalSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter)~^~implicit +VALIDATION_ERROR_03427401~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter~^~core~^~The spec valid usage text states 'If waitSemaphoreValuesCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a pointer to an array of waitSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter)~^~implicit +VALIDATION_ERROR_0342b00b~^~N~^~Unknown~^~vkQueueSubmit~^~VUID-VkD3D12FenceSubmitInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-sType-sType)~^~implicit VALIDATION_ERROR_0361a801~^~N~^~Unknown~^~vkCmdDebugMarkerBeginEXT~^~VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter~^~core~^~The spec valid usage text states 'pMarkerName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter)~^~implicit VALIDATION_ERROR_0361c40d~^~N~^~Unknown~^~vkCmdDebugMarkerBeginEXT~^~VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_0362b00b~^~Y~^~Unknown~^~vkCmdDebugMarkerBeginEXT~^~VUID-VkDebugMarkerMarkerInfoEXT-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-sType-sType)~^~implicit, TBD in parameter validation layer. @@ -268,8 +269,8 @@ VALIDATION_ERROR_04200514~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAll VALIDATION_ERROR_04200516~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651~^~core~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, the buffer must have been created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00651)~^~ VALIDATION_ERROR_04200518~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652~^~core~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00652)~^~ VALIDATION_ERROR_0420051a~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653~^~core~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00653)~^~ -VALIDATION_ERROR_0420051c~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654~^~(VK_KHX_external_memory_win32,VK_KHX_external_memory_fd)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654)~^~ -VALIDATION_ERROR_0420051e~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655~^~(VK_KHX_external_memory_win32,VK_KHX_external_memory_fd)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655)~^~ +VALIDATION_ERROR_0420051c~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654~^~(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-00654)~^~ +VALIDATION_ERROR_0420051e~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655~^~(VK_KHR_external_memory_win32,VK_KHR_external_memory_fd)~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-00655)~^~ VALIDATION_ERROR_04201a01~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-parameter~^~core~^~The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-buffer-parameter)~^~implicit VALIDATION_ERROR_0420a001~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-parameter~^~core~^~The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-image-parameter)~^~implicit VALIDATION_ERROR_0422b00b~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDedicatedAllocationMemoryAllocateInfoNV-sType-sType)~^~implicit, TBD in parameter validation layer. @@ -329,7 +330,7 @@ VALIDATION_ERROR_056002ea~^~N~^~Unknown~^~vkCreateDevice~^~VUID-VkDeviceCreateIn VALIDATION_ERROR_056002ec~^~N~^~Unknown~^~vkCreateDevice~^~VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374~^~(VK_KHR_maintenance1)+(VK_AMD_negative_viewport_height)~^~The spec valid usage text states 'ppEnabledExtensionNames must not contain both VK_KHR_maintenance1 and VK_AMD_negative_viewport_height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374)~^~ VALIDATION_ERROR_05609005~^~Y~^~Unknown~^~vkCreateDevice~^~VUID-VkDeviceCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_05615a01~^~N~^~Unknown~^~vkCreateDevice~^~VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter~^~core~^~The spec valid usage text states 'If pEnabledFeatures is not NULL, pEnabledFeatures must be a pointer to a valid VkPhysicalDeviceFeatures structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter)~^~implicit -VALIDATION_ERROR_0561c40d~^~N~^~Unknown~^~vkCreateDevice~^~VUID-VkDeviceCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceFeatures2KHR, VkPhysicalDeviceMultiviewFeaturesKHX, or VkDeviceGroupDeviceCreateInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-pNext)~^~implicit +VALIDATION_ERROR_0561c40d~^~N~^~Unknown~^~vkCreateDevice~^~VUID-VkDeviceCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceFeatures2KHR, VkPhysicalDevice16BitStorageFeaturesKHR, VkPhysicalDeviceVariablePointerFeaturesKHR, VkPhysicalDeviceMultiviewFeaturesKHX, or VkDeviceGroupDeviceCreateInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-pNext)~^~implicit VALIDATION_ERROR_0561fe01~^~Y~^~Unknown~^~vkCreateDevice~^~VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter~^~core~^~The spec valid usage text states 'pQueueCreateInfos must be a pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter)~^~implicit VALIDATION_ERROR_05628e01~^~Y~^~Unknown~^~vkCreateDevice~^~VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter~^~core~^~The spec valid usage text states 'If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a pointer to an array of enabledExtensionCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter)~^~implicit VALIDATION_ERROR_05629001~^~Y~^~Unknown~^~vkCreateDevice~^~VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter~^~core~^~The spec valid usage text states 'If enabledLayerCount is not 0, ppEnabledLayerNames must be a pointer to an array of enabledLayerCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter)~^~implicit @@ -427,41 +428,42 @@ VALIDATION_ERROR_07c003ea~^~N~^~Unknown~^~vkCmdDrawIndirect~^~VUID-VkDrawIndirec VALIDATION_ERROR_07e09005~^~Y~^~Unknown~^~vkCreateEvent~^~VUID-VkEventCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_07e1c40d~^~Y~^~Unknown~^~vkCreateEvent~^~VUID-VkEventCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_07e2b00b~^~Y~^~Unknown~^~vkCreateEvent~^~VUID-VkEventCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_08000520~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryAllocateInfoKHX-handleTypes-00656~^~core~^~The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatPropertiesKHX or VkExternalBufferPropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHX-handleTypes-00656)~^~ -VALIDATION_ERROR_08009e01~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryAllocateInfoKHX-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHX-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_0801c40d~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryAllocateInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0802b00b~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryAllocateInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHX-sType-sType)~^~implicit -VALIDATION_ERROR_08209e01~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_0821c40d~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkExportMemoryAllocateInfoNV-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-pNext-pNext)~^~implicit -VALIDATION_ERROR_0822b00b~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkExportMemoryAllocateInfoNV-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_08400522~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryWin32HandleInfoKHX-handleTypes-00657~^~core~^~The spec valid usage text states 'If VkExportMemoryAllocateInfoKHX::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX, VkExportMemoryWin32HandleInfoKHX must not be in the pNext chain of VkMemoryAllocateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHX-handleTypes-00657)~^~ -VALIDATION_ERROR_0840f401~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryWin32HandleInfoKHX-pAttributes-parameter~^~core~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHX-pAttributes-parameter)~^~implicit -VALIDATION_ERROR_0841c40d~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryWin32HandleInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0842b00b~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryWin32HandleInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHX-sType-sType)~^~implicit -VALIDATION_ERROR_0860f401~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter~^~core~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter)~^~implicit -VALIDATION_ERROR_0861c40d~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkExportMemoryWin32HandleInfoNV-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-pNext-pNext)~^~implicit -VALIDATION_ERROR_0862b00b~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkExportMemoryWin32HandleInfoNV-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_088008c8~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreCreateInfoKHX-handleTypes-01124~^~core~^~The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphorePropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHX-handleTypes-01124)~^~ -VALIDATION_ERROR_08809e01~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreCreateInfoKHX-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHX-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_0881c40d~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreCreateInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0882b00b~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreCreateInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHX-sType-sType)~^~implicit -VALIDATION_ERROR_08a008ca~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreWin32HandleInfoKHX-handleTypes-01125~^~core~^~The spec valid usage text states 'If VkExportSemaphoreCreateInfoKHX::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX, VkExportSemaphoreWin32HandleInfoKHX must not be in the pNext chain of VkSemaphoreCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHX-handleTypes-01125)~^~ -VALIDATION_ERROR_08a0f401~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreWin32HandleInfoKHX-pAttributes-parameter~^~core~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHX-pAttributes-parameter)~^~implicit -VALIDATION_ERROR_08a1c40d~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreWin32HandleInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHX-pNext-pNext)~^~implicit -VALIDATION_ERROR_08a2b00b~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreWin32HandleInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHX-sType-sType)~^~implicit -VALIDATION_ERROR_08c09e01~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkExternalMemoryBufferCreateInfoKHX-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHX-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_08c1c40d~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkExternalMemoryBufferCreateInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHX-pNext-pNext)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_08c2b00b~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkExternalMemoryBufferCreateInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHX-sType-sType)~^~implicit -VALIDATION_ERROR_08e09e01~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoKHX-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHX-handleTypes-parameter)~^~implicit -VALIDATION_ERROR_08e09e03~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoKHX-handleTypes-requiredbitmask~^~core~^~The spec valid usage text states 'handleTypes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHX-handleTypes-requiredbitmask)~^~implicit -VALIDATION_ERROR_08e1c40d~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHX-pNext-pNext)~^~implicit -VALIDATION_ERROR_08e2b00b~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHX-sType-sType)~^~implicit +VALIDATION_ERROR_08000520~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryAllocateInfoKHR-handleTypes-00656~^~core~^~The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatPropertiesKHR or VkExternalBufferPropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHR-handleTypes-00656)~^~ +VALIDATION_ERROR_08009e01~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryAllocateInfoKHR-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHR-handleTypes-parameter)~^~implicit +VALIDATION_ERROR_0801c40d~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryAllocateInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHR-pNext-pNext)~^~implicit +VALIDATION_ERROR_0802b00b~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryAllocateInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHR-sType-sType)~^~implicit +VALIDATION_ERROR_08209e01~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter)~^~implicit +VALIDATION_ERROR_0821c40d~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkExportMemoryAllocateInfoNV-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-pNext-pNext)~^~implicit +VALIDATION_ERROR_0822b00b~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkExportMemoryAllocateInfoNV-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-sType-sType)~^~implicit +VALIDATION_ERROR_08400522~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657~^~core~^~The spec valid usage text states 'If VkExportMemoryAllocateInfoKHR::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR, VkExportMemoryWin32HandleInfoKHR must not be in the pNext chain of VkMemoryAllocateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657)~^~ +VALIDATION_ERROR_0840f401~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter~^~core~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter)~^~implicit +VALIDATION_ERROR_0841c40d~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryWin32HandleInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-pNext-pNext)~^~implicit +VALIDATION_ERROR_0842b00b~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType)~^~implicit +VALIDATION_ERROR_0860f401~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter~^~core~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter)~^~implicit +VALIDATION_ERROR_0861c40d~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkExportMemoryWin32HandleInfoNV-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-pNext-pNext)~^~implicit +VALIDATION_ERROR_0862b00b~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkExportMemoryWin32HandleInfoNV-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-sType-sType)~^~implicit +VALIDATION_ERROR_088008c8~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreCreateInfoKHR-handleTypes-01124~^~core~^~The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphorePropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHR-handleTypes-01124)~^~ +VALIDATION_ERROR_08809e01~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreCreateInfoKHR-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHR-handleTypes-parameter)~^~implicit +VALIDATION_ERROR_0881c40d~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreCreateInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHR-pNext-pNext)~^~implicit +VALIDATION_ERROR_0882b00b~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreCreateInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHR-sType-sType)~^~implicit +VALIDATION_ERROR_08a008ca~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125~^~core~^~The spec valid usage text states 'If VkExportSemaphoreCreateInfoKHR::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, VkExportSemaphoreWin32HandleInfoKHR must not be in the pNext chain of VkSemaphoreCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125)~^~ +VALIDATION_ERROR_08a0f401~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter~^~core~^~The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter)~^~implicit +VALIDATION_ERROR_08a1c40d~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreWin32HandleInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-pNext-pNext)~^~implicit +VALIDATION_ERROR_08a2b00b~^~N~^~Unknown~^~vkCreateSemaphore~^~VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType)~^~implicit +VALIDATION_ERROR_08c09e01~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkExternalMemoryBufferCreateInfoKHR-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHR-handleTypes-parameter)~^~implicit +VALIDATION_ERROR_08c1c40d~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkExternalMemoryBufferCreateInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHR-pNext-pNext)~^~implicit, TBD in parameter validation layer. +VALIDATION_ERROR_08c2b00b~^~N~^~Unknown~^~vkCreateBuffer~^~VUID-VkExternalMemoryBufferCreateInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHR-sType-sType)~^~implicit +VALIDATION_ERROR_08e09e01~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoKHR-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHR-handleTypes-parameter)~^~implicit +VALIDATION_ERROR_08e09e03~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoKHR-handleTypes-requiredbitmask~^~core~^~The spec valid usage text states 'handleTypes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHR-handleTypes-requiredbitmask)~^~implicit +VALIDATION_ERROR_08e1c40d~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHR-pNext-pNext)~^~implicit +VALIDATION_ERROR_08e2b00b~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHR-sType-sType)~^~implicit VALIDATION_ERROR_09009e01~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter~^~core~^~The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter)~^~implicit VALIDATION_ERROR_0901c40d~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoNV-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-pNext-pNext)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_0902b00b~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkExternalMemoryImageCreateInfoNV-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-sType-sType)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_09209001~^~Y~^~Unknown~^~vkCreateFence~^~VUID-VkFenceCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkFenceCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. -VALIDATION_ERROR_0921c40d~^~Y~^~Unknown~^~vkCreateFence~^~VUID-VkFenceCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. +VALIDATION_ERROR_0921c40d~^~Y~^~Unknown~^~vkCreateFence~^~VUID-VkFenceCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportFenceCreateInfoKHR or VkExportFenceWin32HandleInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_0922b00b~^~Y~^~Unknown~^~vkCreateFence~^~VUID-VkFenceCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. +VALIDATION_ERROR_0922b00f~^~N~^~None~^~VkFenceCreateInfo~^~VUID-VkFenceCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-sType-unique)~^~implicit VALIDATION_ERROR_09400009~^~Y~^~FramebufferCreateErrors~^~vkCreateFramebuffer~^~VUID-VkFramebufferCreateInfo-commonparent~^~core~^~The spec valid usage text states 'Both of renderPass, and the elements of pAttachments that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-commonparent)~^~implicit VALIDATION_ERROR_094006d8~^~Y~^~FramebufferCreateErrors~^~vkCreateFramebuffer~^~VUID-VkFramebufferCreateInfo-attachmentCount-00876~^~core~^~The spec valid usage text states 'attachmentCount must be equal to the attachment count specified in renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-attachmentCount-00876)~^~ VALIDATION_ERROR_094006da~^~Y~^~FramebufferCreateErrors~^~vkCreateFramebuffer~^~VUID-VkFramebufferCreateInfo-pAttachments-00877~^~core~^~The spec valid usage text states 'Any given element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00877)~^~ @@ -534,7 +536,7 @@ VALIDATION_ERROR_09609001~^~Y~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-VkGra VALIDATION_ERROR_0960be01~^~Y~^~None~^~vkCreateGraphicsPipelines~^~VUID-VkGraphicsPipelineCreateInfo-layout-parameter~^~core~^~The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-parameter)~^~implicit VALIDATION_ERROR_09615601~^~N~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter~^~core~^~The spec valid usage text states 'If pDynamicState is not NULL, pDynamicState must be a pointer to a valid VkPipelineDynamicStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter)~^~implicit VALIDATION_ERROR_09619801~^~N~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter~^~core~^~The spec valid usage text states 'pInputAssemblyState must be a pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter)~^~implicit -VALIDATION_ERROR_0961c40d~^~Y~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-VkGraphicsPipelineCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. +VALIDATION_ERROR_0961c40d~^~Y~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-VkGraphicsPipelineCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineDiscardRectangleStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pNext-pNext)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_09620801~^~N~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter~^~core~^~The spec valid usage text states 'pRasterizationState must be a pointer to a valid VkPipelineRasterizationStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter)~^~implicit VALIDATION_ERROR_09623e01~^~Y~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-VkGraphicsPipelineCreateInfo-pStages-parameter~^~core~^~The spec valid usage text states 'pStages must be a pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-parameter)~^~implicit VALIDATION_ERROR_09626801~^~N~^~Unknown~^~vkCreateGraphicsPipelines~^~VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter~^~core~^~The spec valid usage text states 'pVertexInputState must be a pointer to a valid VkPipelineVertexInputStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter)~^~implicit @@ -641,20 +643,21 @@ VALIDATION_ERROR_09e007b0~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo VALIDATION_ERROR_09e007b2~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-tiling-00985~^~core~^~The spec valid usage text states 'If tiling is VK_IMAGE_TILING_OPTIMAL, and VkFormatProperties::optimalTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, usage must not contain VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-tiling-00985)~^~ VALIDATION_ERROR_09e007b4~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-tiling-00986~^~core~^~The spec valid usage text states 'If tiling is VK_IMAGE_TILING_OPTIMAL, and VkFormatProperties::optimalTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, usage must not contain VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-tiling-00986)~^~ VALIDATION_ERROR_09e007b6~^~Y~^~SparseBindingImageBufferCreate~^~vkCreateImage~^~VUID-VkImageCreateInfo-flags-00987~^~core~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-00987)~^~ -VALIDATION_ERROR_09e007b8~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-pNext-00988~^~(VK_NV_external_memory+VK_KHX_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, it must not contain an instance of VkExternalMemoryImageCreateInfoKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00988)~^~ -VALIDATION_ERROR_09e007ba~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-pNext-00989~^~(VK_KHX_external_memory+VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoKHX, and any of the handle types specified in VkExternalMemoryImageCreateInfoKHX::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2KHR in VkExternalImageFormatPropertiesKHX::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationImageCreateInfoNV with its dedicatedAllocation field set to VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00989)~^~ -VALIDATION_ERROR_09e007bc~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-pNext-00990~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoKHX, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesKHX::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2KHR with format, type, tiling, usage, and flags equal to those in this structure, and with an instance of VkPhysicalDeviceExternalImageFormatInfoKHX in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoKHX::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00990)~^~ +VALIDATION_ERROR_09e007b8~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-pNext-00988~^~(VK_NV_external_memory+VK_KHR_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, it must not contain an instance of VkExternalMemoryImageCreateInfoKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00988)~^~ +VALIDATION_ERROR_09e007ba~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-pNext-00989~^~core~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoKHR, and any of the handle types specified in VkExternalMemoryImageCreateInfoKHR::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2KHR in VkExternalImageFormatPropertiesKHR::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationImageCreateInfoNV with its dedicatedAllocation field set to VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00989)~^~ +VALIDATION_ERROR_09e007bc~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-pNext-00990~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoKHR, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesKHR::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2KHR with format, type, tiling, usage, and flags equal to those in this structure, and with an instance of VkPhysicalDeviceExternalImageFormatInfoKHR in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoKHR::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00990)~^~ VALIDATION_ERROR_09e007be~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-pNext-00991~^~(VK_NV_external_memory+VK_NV_external_memory_capabilities)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesNV::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalImageFormatPropertiesNV with format, type, tiling, usage, and flags equal to those in this structure, and with externalHandleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoNV::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00991)~^~ -VALIDATION_ERROR_09e007c0~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-flags-00992~^~(VK_KHX_device_group)~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_BIND_SFR_BIT_KHX, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D, and tiling must be VK_IMAGE_TILING_OPTIMAL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-00992)~^~ +VALIDATION_ERROR_09e007c0~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-flags-00992~^~(VK_KHX_device_group)~^~The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_BIND_SFR_BIT_KHX, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D, and tiling must be VK_IMAGE_TILING_OPTIMAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-00992)~^~ VALIDATION_ERROR_09e007c2~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-initialLayout-00993~^~core~^~The spec valid usage text states 'initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-initialLayout-00993)~^~ VALIDATION_ERROR_09e00ae0~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-sharingMode-01392~^~!(VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-01392)~^~ VALIDATION_ERROR_09e00b18~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-sharingMode-01420~^~(VK_KHR_get_physical_device_properties2)~^~The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2KHR for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-01420)~^~ VALIDATION_ERROR_09e00b1a~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-physicalDeviceCount-01421~^~(VK_KHX_device_group)~^~The spec valid usage text states 'If the logical device was created with VkDeviceGroupDeviceCreateInfoKHX::physicalDeviceCount equal to 1, flags must not contain VK_IMAGE_CREATE_BIND_SFR_BIT_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-physicalDeviceCount-01421)~^~ +VALIDATION_ERROR_09e00b46~^~N~^~None~^~VkImageCreateInfo~^~VUID-VkImageCreateInfo-pNext-01443~^~(VK_KHR_external_memory,VK_NV_external_memory)~^~The spec valid usage text states 'If the pNext chain includes a' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01443)~^~ VALIDATION_ERROR_09e09001~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-parameter)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_09e09201~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-format-parameter~^~core~^~The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-format-parameter)~^~implicit VALIDATION_ERROR_09e0ac01~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-imageType-parameter~^~core~^~The spec valid usage text states 'imageType must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-parameter)~^~implicit VALIDATION_ERROR_09e0b801~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-initialLayout-parameter~^~core~^~The spec valid usage text states 'initialLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-initialLayout-parameter)~^~implicit -VALIDATION_ERROR_09e1c40d~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationImageCreateInfoNV or VkImageSwapchainCreateInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-pNext-pNext)~^~implicit +VALIDATION_ERROR_09e1c40d~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationImageCreateInfoNV, VkImageSwapchainCreateInfoKHX, VkExternalMemoryImageCreateInfoKHR, or VkExternalMemoryImageCreateInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-pNext-pNext)~^~implicit VALIDATION_ERROR_09e2b00b~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_09e2b00f~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sType-unique)~^~implicit VALIDATION_ERROR_09e2b401~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-samples-parameter~^~core~^~The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-samples-parameter)~^~implicit @@ -664,11 +667,11 @@ VALIDATION_ERROR_09e30601~^~N~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo VALIDATION_ERROR_09e30603~^~Y~^~Unknown~^~vkCreateImage~^~VUID-VkImageCreateInfo-usage-requiredbitmask~^~core~^~The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-usage-requiredbitmask)~^~implicit VALIDATION_ERROR_0a00095a~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01197~^~core~^~The spec valid usage text states 'oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01197)~^~ VALIDATION_ERROR_0a00095c~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-newLayout-01198~^~core~^~The spec valid usage text states 'newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-newLayout-01198)~^~ -VALIDATION_ERROR_0a00095e~^~N~^~None~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01199~^~!(VK_KHX_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01199)~^~ -VALIDATION_ERROR_0a000960~^~N~^~None~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01200~^~!(VK_KHX_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01200)~^~ -VALIDATION_ERROR_0a000962~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01201~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01201)~^~ -VALIDATION_ERROR_0a000964~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01202~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHX (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01202)~^~ -VALIDATION_ERROR_0a000966~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01203~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHX (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01203)~^~ +VALIDATION_ERROR_0a00095e~^~N~^~None~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01199~^~!(VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01199)~^~ +VALIDATION_ERROR_0a000960~^~N~^~None~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01200~^~!(VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01200)~^~ +VALIDATION_ERROR_0a000962~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01201~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01201)~^~ +VALIDATION_ERROR_0a000964~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01202~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHR (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01202)~^~ +VALIDATION_ERROR_0a000966~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01203~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHR (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01203)~^~ VALIDATION_ERROR_0a00096a~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01205~^~core~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01205)~^~ VALIDATION_ERROR_0a00096c~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-subresourceRange-01206~^~core~^~The spec valid usage text states 'subresourceRange must be a valid image subresource range for the image (see Image Views)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01206)~^~ VALIDATION_ERROR_0a00096e~^~Y~^~InvalidBarriers~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01207~^~core~^~The spec valid usage text states 'If image has a depth/stencil format with both depth and stencil components, then aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01207)~^~ @@ -678,8 +681,8 @@ VALIDATION_ERROR_0a000974~^~Y~^~InvalidBarriers~^~vkCmdPipelineBarrier~^~VUID-Vk VALIDATION_ERROR_0a000976~^~Y~^~InvalidBarriers~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01211~^~core~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01211)~^~ VALIDATION_ERROR_0a000978~^~Y~^~InvalidBarriers~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01212~^~core~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01212)~^~ VALIDATION_ERROR_0a00097a~^~Y~^~InvalidBarriers~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-oldLayout-01213~^~core~^~The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01213)~^~ -VALIDATION_ERROR_0a000aca~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01381~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01381)~^~ -VALIDATION_ERROR_0a000acc~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01382~^~(VK_KHX_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or VK_QUEUE_FAMILY_EXTERNAL_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01382)~^~ +VALIDATION_ERROR_0a000aca~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01381~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01381)~^~ +VALIDATION_ERROR_0a000acc~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-01382~^~(VK_KHR_external_memory)~^~The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or VK_QUEUE_FAMILY_EXTERNAL_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01382)~^~ VALIDATION_ERROR_0a006801~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-dstAccessMask-parameter~^~core~^~The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-dstAccessMask-parameter)~^~implicit VALIDATION_ERROR_0a00a001~^~N~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-image-parameter~^~core~^~The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-parameter)~^~implicit VALIDATION_ERROR_0a00d401~^~Y~^~Unknown~^~vkCmdPipelineBarrier~^~VUID-VkImageMemoryBarrier-newLayout-parameter~^~core~^~The spec valid usage text states 'newLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-newLayout-parameter)~^~implicit @@ -730,12 +733,12 @@ VALIDATION_ERROR_0ac007de~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCr VALIDATION_ERROR_0ac007e0~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01008~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01008)~^~ VALIDATION_ERROR_0ac007e2~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01009~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01009)~^~ VALIDATION_ERROR_0ac007e4~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01010~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01010)~^~ -VALIDATION_ERROR_0ac007e6~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01011~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage containing VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01011)~^~ +VALIDATION_ERROR_0ac007e6~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01011~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01011)~^~ VALIDATION_ERROR_0ac007e8~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01012~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01012)~^~ VALIDATION_ERROR_0ac007ea~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01013~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01013)~^~ VALIDATION_ERROR_0ac007ec~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01014~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01014)~^~ VALIDATION_ERROR_0ac007ee~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01015~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01015)~^~ -VALIDATION_ERROR_0ac007f0~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01016~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage containing VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01016)~^~ +VALIDATION_ERROR_0ac007f0~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01016~^~core~^~The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01016)~^~ VALIDATION_ERROR_0ac007f2~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-subresourceRange-01017~^~core~^~The spec valid usage text states 'subresourceRange must be a valid image subresource range for image (see Image Views)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01017)~^~ VALIDATION_ERROR_0ac007f4~^~Y~^~CreateImageViewDifferentClass~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01018~^~core~^~The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01018)~^~Multi-purposing this for some format compatibility checks, need unique enums. VALIDATION_ERROR_0ac007f6~^~Y~^~CreateImageViewNoMutableFormatBit~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-image-01019~^~core~^~The spec valid usage text states 'If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be identical to the format used to create image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01019)~^~ @@ -749,38 +752,47 @@ VALIDATION_ERROR_0ac1c40d~^~Y~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCr VALIDATION_ERROR_0ac2b00b~^~Y~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_0ac2ea01~^~N~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-subresourceRange-parameter~^~core~^~The spec valid usage text states 'subresourceRange must be a valid VkImageSubresourceRange structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-parameter)~^~implicit VALIDATION_ERROR_0ac30801~^~Y~^~Unknown~^~vkCreateImageView~^~VUID-VkImageViewCreateInfo-viewType-parameter~^~core~^~The spec valid usage text states 'viewType must be a valid VkImageViewType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-viewType-parameter)~^~implicit -VALIDATION_ERROR_0ae00536~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHX~^~VUID-VkImportMemoryFdInfoKHX-handleType-00667~^~core~^~The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatPropertiesKHX or VkExternalBufferPropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-handleType-00667)~^~ -VALIDATION_ERROR_0ae00538~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHX~^~VUID-VkImportMemoryFdInfoKHX-fd-00668~^~core~^~The spec valid usage text states 'The memory from which fd was exported must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-fd-00668)~^~ -VALIDATION_ERROR_0ae0053a~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHX~^~VUID-VkImportMemoryFdInfoKHX-handleType-00669~^~core~^~The spec valid usage text states 'If handleType is not 0, it must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-handleType-00669)~^~ -VALIDATION_ERROR_0ae0053c~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHX~^~VUID-VkImportMemoryFdInfoKHX-handleType-00670~^~core~^~The spec valid usage text states 'If handleType is not 0, fd must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-handleType-00670)~^~ -VALIDATION_ERROR_0ae09c01~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHX~^~VUID-VkImportMemoryFdInfoKHX-handleType-parameter~^~core~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-handleType-parameter)~^~implicit -VALIDATION_ERROR_0ae1c40d~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHX~^~VUID-VkImportMemoryFdInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0ae2b00b~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHX~^~VUID-VkImportMemoryFdInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-sType-sType)~^~implicit -VALIDATION_ERROR_0b000524~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHX-handleType-00658~^~core~^~The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatPropertiesKHX or VkExternalBufferPropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handleType-00658)~^~ -VALIDATION_ERROR_0b000526~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHX-handle-00659~^~core~^~The spec valid usage text states 'The memory from which handle was exported must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handle-00659)~^~ -VALIDATION_ERROR_0b000528~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHX-handleType-00660~^~core~^~The spec valid usage text states 'If handleType is not 0, it must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handleType-00660)~^~ -VALIDATION_ERROR_0b00052a~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHX-handleType-00661~^~core~^~The spec valid usage text states 'If handleType is not 0, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handleType-00661)~^~ -VALIDATION_ERROR_0b009c01~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHX-handleType-parameter~^~core~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handleType-parameter)~^~implicit -VALIDATION_ERROR_0b01c40d~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0b02b00b~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-sType-sType)~^~implicit -VALIDATION_ERROR_0b200a5e~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327~^~core~^~The spec valid usage text states 'handleType must not have more than one bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327)~^~ -VALIDATION_ERROR_0b200a60~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkImportMemoryWin32HandleInfoNV-handle-01328~^~core~^~The spec valid usage text states 'handle must be a valid handle to memory, obtained as specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handle-01328)~^~ -VALIDATION_ERROR_0b209c01~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter~^~core~^~The spec valid usage text states 'handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter)~^~implicit -VALIDATION_ERROR_0b21c40d~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkImportMemoryWin32HandleInfoNV-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-pNext-pNext)~^~implicit -VALIDATION_ERROR_0b22b00b~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHX~^~VUID-VkImportMemoryWin32HandleInfoNV-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-sType-sType)~^~implicit -VALIDATION_ERROR_0b4008ee~^~N~^~Unknown~^~vkImportSemaphoreFdKHX~^~VUID-VkImportSemaphoreFdInfoKHX-handleType-01143~^~core~^~The spec valid usage text states 'handleType must be a value included in the Handle Type Permanence for VkImportSemaphoreFdInfoKHX table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-handleType-01143)~^~ -VALIDATION_ERROR_0b4008f0~^~N~^~Unknown~^~vkImportSemaphoreFdKHX~^~VUID-VkImportSemaphoreFdInfoKHX-handleType-01144~^~core~^~The spec valid usage text states 'The semaphore from which handleType was exported must have been created on the same underlying physical device as semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-handleType-01144)~^~ -VALIDATION_ERROR_0b409c01~^~Y~^~Unknown~^~vkImportSemaphoreFdKHX~^~VUID-VkImportSemaphoreFdInfoKHX-handleType-parameter~^~core~^~The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-handleType-parameter)~^~implicit -VALIDATION_ERROR_0b41c40d~^~Y~^~Unknown~^~vkImportSemaphoreFdKHX~^~VUID-VkImportSemaphoreFdInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0b42b00b~^~Y~^~Unknown~^~vkImportSemaphoreFdKHX~^~VUID-VkImportSemaphoreFdInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-sType-sType)~^~implicit -VALIDATION_ERROR_0b42b801~^~N~^~Unknown~^~vkImportSemaphoreFdKHX~^~VUID-VkImportSemaphoreFdInfoKHX-semaphore-parameter~^~core~^~The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-semaphore-parameter)~^~implicit -VALIDATION_ERROR_0b6008e8~^~N~^~Unknown~^~vkImportSemaphoreWin32HandleKHX~^~VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-01140~^~core~^~The spec valid usage text states 'handleType must be a value included in the Handle Type Permanence for VkImportSemaphoreWin32HandleInfoKHX table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-01140)~^~ -VALIDATION_ERROR_0b6008ea~^~N~^~Unknown~^~vkImportSemaphoreWin32HandleKHX~^~VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-01141~^~core~^~The spec valid usage text states 'The semaphore from which handleType was exported must have been created on the same underlying physical device as semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-01141)~^~ -VALIDATION_ERROR_0b609c01~^~N~^~Unknown~^~vkImportSemaphoreWin32HandleKHX~^~VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-parameter~^~core~^~The spec valid usage text states 'handleType must be a valid combination of VkExternalSemaphoreHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-parameter)~^~implicit -VALIDATION_ERROR_0b609c03~^~Y~^~Unknown~^~vkImportSemaphoreWin32HandleKHX~^~VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-requiredbitmask~^~core~^~The spec valid usage text states 'handleType must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-requiredbitmask)~^~implicit -VALIDATION_ERROR_0b61c40d~^~Y~^~Unknown~^~vkImportSemaphoreWin32HandleKHX~^~VUID-VkImportSemaphoreWin32HandleInfoKHX-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-pNext-pNext)~^~implicit -VALIDATION_ERROR_0b62b00b~^~Y~^~Unknown~^~vkImportSemaphoreWin32HandleKHX~^~VUID-VkImportSemaphoreWin32HandleInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-sType-sType)~^~implicit -VALIDATION_ERROR_0b62b801~^~N~^~Unknown~^~vkImportSemaphoreWin32HandleKHX~^~VUID-VkImportSemaphoreWin32HandleInfoKHX-semaphore-parameter~^~core~^~The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-semaphore-parameter)~^~implicit +VALIDATION_ERROR_0ae00536~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-VkImportMemoryFdInfoKHR-handleType-00667~^~core~^~The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatPropertiesKHR or VkExternalBufferPropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00667)~^~ +VALIDATION_ERROR_0ae00538~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-VkImportMemoryFdInfoKHR-fd-00668~^~core~^~The spec valid usage text states 'The memory from which fd was exported must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-fd-00668)~^~ +VALIDATION_ERROR_0ae0053a~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-VkImportMemoryFdInfoKHR-handleType-00669~^~core~^~The spec valid usage text states 'If handleType is not 0, it must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00669)~^~ +VALIDATION_ERROR_0ae0053c~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-VkImportMemoryFdInfoKHR-handleType-00670~^~core~^~The spec valid usage text states 'If handleType is not 0, fd must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00670)~^~ +VALIDATION_ERROR_0ae09c01~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-VkImportMemoryFdInfoKHR-handleType-parameter~^~core~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-parameter)~^~implicit +VALIDATION_ERROR_0ae1c40d~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-VkImportMemoryFdInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-pNext-pNext)~^~implicit +VALIDATION_ERROR_0ae2b00b~^~N~^~Unknown~^~vkGetMemoryWin32HandlePropertiesKHR~^~VUID-VkImportMemoryFdInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-sType-sType)~^~implicit +VALIDATION_ERROR_0b000524~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658~^~core~^~The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatPropertiesKHR or VkExternalBufferPropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658)~^~ +VALIDATION_ERROR_0b000526~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659~^~core~^~The spec valid usage text states 'The memory from which handle was exported, or the memory named by name must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659)~^~ +VALIDATION_ERROR_0b000528~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660~^~core~^~The spec valid usage text states 'If handleType is not 0, it must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660)~^~ +VALIDATION_ERROR_0b00052a~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661~^~core~^~The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661)~^~ +VALIDATION_ERROR_0b000b3e~^~N~^~None~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439~^~core~^~The spec valid usage text states 'If handleType is not VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439)~^~ +VALIDATION_ERROR_0b000b40~^~N~^~None~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440~^~core~^~The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid memory resource of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440)~^~ +VALIDATION_ERROR_0b000b42~^~N~^~None~^~VkImportMemoryWin32HandleInfoKHR~^~VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441~^~core~^~The spec valid usage text states 'if handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441)~^~ +VALIDATION_ERROR_0b009c01~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter~^~core~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter)~^~implicit +VALIDATION_ERROR_0b01c40d~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-pNext-pNext)~^~implicit +VALIDATION_ERROR_0b02b00b~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType)~^~implicit +VALIDATION_ERROR_0b200a5e~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327~^~core~^~The spec valid usage text states 'handleType must not have more than one bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327)~^~ +VALIDATION_ERROR_0b200a60~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkImportMemoryWin32HandleInfoNV-handle-01328~^~core~^~The spec valid usage text states 'handle must be a valid handle to memory, obtained as specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handle-01328)~^~ +VALIDATION_ERROR_0b209c01~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter~^~core~^~The spec valid usage text states 'handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter)~^~implicit +VALIDATION_ERROR_0b21c40d~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkImportMemoryWin32HandleInfoNV-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-pNext-pNext)~^~implicit +VALIDATION_ERROR_0b22b00b~^~N~^~Unknown~^~vkGetMemoryFdPropertiesKHR~^~VUID-VkImportMemoryWin32HandleInfoNV-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-sType-sType)~^~implicit +VALIDATION_ERROR_0b4008ee~^~N~^~Unknown~^~vkImportSemaphoreFdKHR~^~VUID-VkImportSemaphoreFdInfoKHR-handleType-01143~^~core~^~The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportSemaphoreFdInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-01143)~^~ +VALIDATION_ERROR_0b4008f0~^~N~^~Unknown~^~vkImportSemaphoreFdKHR~^~VUID-VkImportSemaphoreFdInfoKHR-handleType-01144~^~core~^~The spec valid usage text states 'The semaphore from which handleType was exported must have been created on the same underlying physical device as semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-01144)~^~ +VALIDATION_ERROR_0b409001~^~Y~^~None~^~VkImportSemaphoreFdInfoKHR~^~VUID-VkImportSemaphoreFdInfoKHR-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkSemaphoreImportFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-flags-parameter)~^~implicit +VALIDATION_ERROR_0b409c01~^~Y~^~Unknown~^~vkImportSemaphoreFdKHR~^~VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter~^~core~^~The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter)~^~implicit +VALIDATION_ERROR_0b41c40d~^~Y~^~Unknown~^~vkImportSemaphoreFdKHR~^~VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext)~^~implicit +VALIDATION_ERROR_0b42b00b~^~Y~^~Unknown~^~vkImportSemaphoreFdKHR~^~VUID-VkImportSemaphoreFdInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-sType-sType)~^~implicit +VALIDATION_ERROR_0b42b801~^~N~^~Unknown~^~vkImportSemaphoreFdKHR~^~VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter~^~core~^~The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter)~^~implicit +VALIDATION_ERROR_0b6008e8~^~N~^~Unknown~^~vkImportSemaphoreWin32HandleKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140~^~core~^~The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140)~^~ +VALIDATION_ERROR_0b6008ea~^~N~^~Unknown~^~vkImportSemaphoreWin32HandleKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01141~^~core~^~The spec valid usage text states 'The semaphore from which handleType or name was exported must have been created on the same underlying physical device as semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01141)~^~ +VALIDATION_ERROR_0b600b74~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466~^~core~^~The spec valid usage text states 'If handleType is not VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466)~^~ +VALIDATION_ERROR_0b600b76~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467~^~core~^~The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467)~^~ +VALIDATION_ERROR_0b600b78~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468~^~core~^~The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468)~^~ +VALIDATION_ERROR_0b600b7a~^~N~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469~^~core~^~The spec valid usage text states 'If handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469)~^~ +VALIDATION_ERROR_0b609001~^~Y~^~None~^~VkImportSemaphoreWin32HandleInfoKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter~^~core~^~The spec valid usage text states 'flags must be a valid combination of VkSemaphoreImportFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter)~^~implicit +VALIDATION_ERROR_0b609c01~^~Y~^~Unknown~^~vkImportSemaphoreWin32HandleKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter~^~core~^~The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter)~^~implicit +VALIDATION_ERROR_0b609c03~^~N~^~Unknown~^~vkImportSemaphoreWin32HandleKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-requiredbitmask~^~core~^~The spec valid usage text states 'handleType must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-requiredbitmask)~^~implicit +VALIDATION_ERROR_0b61c40d~^~Y~^~Unknown~^~vkImportSemaphoreWin32HandleKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext)~^~implicit +VALIDATION_ERROR_0b62b00b~^~Y~^~Unknown~^~vkImportSemaphoreWin32HandleKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType)~^~implicit +VALIDATION_ERROR_0b62b801~^~N~^~Unknown~^~vkImportSemaphoreWin32HandleKHR~^~VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter~^~core~^~The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter)~^~implicit VALIDATION_ERROR_0b800a86~^~N~^~Unknown~^~vkCreateIndirectCommandsLayoutNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347~^~core~^~The spec valid usage text states 'tokenCount must be greater than 0 and below VkDeviceGeneratedCommandsLimitsNVX::maxIndirectCommandsLayoutTokenCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347)~^~ VALIDATION_ERROR_0b800a88~^~N~^~Unknown~^~vkCreateIndirectCommandsLayoutNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348~^~core~^~The spec valid usage text states 'If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, then pipelineBindPoint must not be VK_PIPELINE_BIND_POINT_COMPUTE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348)~^~ VALIDATION_ERROR_0b800a8a~^~N~^~Unknown~^~vkCreateIndirectCommandsLayoutNVX~^~VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349~^~core~^~The spec valid usage text states 'If pTokens contains an entry of VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX it must be the first element of the array and there must be only a single element of such token type.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349)~^~ @@ -803,10 +815,11 @@ VALIDATION_ERROR_0bc01a01~^~N~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-VkIndire VALIDATION_ERROR_0bc2fe01~^~Y~^~Unknown~^~vkUnregisterObjectsNVX~^~VUID-VkIndirectCommandsTokenNVX-tokenType-parameter~^~core~^~The spec valid usage text states 'tokenType must be a valid VkIndirectCommandsTokenTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-tokenType-parameter)~^~implicit VALIDATION_ERROR_0be09005~^~Y~^~Unknown~^~vkCreateInstance~^~VUID-VkInstanceCreateInfo-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-flags-zerobitmask)~^~implicit, TBD in parameter validation layer. VALIDATION_ERROR_0be0ee01~^~N~^~Unknown~^~vkCreateInstance~^~VUID-VkInstanceCreateInfo-pApplicationInfo-parameter~^~core~^~The spec valid usage text states 'If pApplicationInfo is not NULL, pApplicationInfo must be a pointer to a valid VkApplicationInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pApplicationInfo-parameter)~^~implicit -VALIDATION_ERROR_0be1c40d~^~N~^~Unknown~^~vkCreateInstance~^~VUID-VkInstanceCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pNext-pNext)~^~implicit +VALIDATION_ERROR_0be1c40d~^~N~^~Unknown~^~vkCreateInstance~^~VUID-VkInstanceCreateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT or VkValidationFlagsEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pNext-pNext)~^~implicit VALIDATION_ERROR_0be28e01~^~Y~^~Unknown~^~vkCreateInstance~^~VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter~^~core~^~The spec valid usage text states 'If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a pointer to an array of enabledExtensionCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter)~^~implicit VALIDATION_ERROR_0be29001~^~Y~^~Unknown~^~vkCreateInstance~^~VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter~^~core~^~The spec valid usage text states 'If enabledLayerCount is not 0, ppEnabledLayerNames must be a pointer to an array of enabledLayerCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter)~^~implicit VALIDATION_ERROR_0be2b00b~^~Y~^~Unknown~^~vkCreateInstance~^~VUID-VkInstanceCreateInfo-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-sType-sType)~^~implicit, TBD in parameter validation layer. +VALIDATION_ERROR_0be2b00f~^~N~^~None~^~VkInstanceCreateInfo~^~VUID-VkInstanceCreateInfo-sType-unique~^~core~^~The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-sType-unique)~^~implicit VALIDATION_ERROR_0c000a4a~^~N~^~Unknown~^~vkCreateMacOSSurfaceMVK~^~VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317~^~core~^~The spec valid usage text states 'pView must be a valid NSView and must be backed by a CALayer instance of type CAMetalLayer.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317)~^~ VALIDATION_ERROR_0c009005~^~Y~^~Unknown~^~vkCreateMacOSSurfaceMVK~^~VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask~^~core~^~The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask)~^~implicit VALIDATION_ERROR_0c01c40d~^~Y~^~Unknown~^~vkCreateMacOSSurfaceMVK~^~VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext~^~core~^~The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext)~^~implicit @@ -828,17 +841,17 @@ VALIDATION_ERROR_0c409001~^~N~^~Unknown~^~vkGetMemoryWin32HandleNV~^~VUID-VkMemo VALIDATION_ERROR_0c42b00b~^~N~^~Unknown~^~vkGetMemoryWin32HandleNV~^~VUID-VkMemoryAllocateFlagsInfoKHX-sType-sType~^~core~^~The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfoKHX-sType-sType)~^~implicit VALIDATION_ERROR_0c6004fa~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-allocationSize-00637~^~core~^~The spec valid usage text states 'allocationSize must be less than or equal to the amount of memory available to the VkMemoryHeap specified by memoryTypeIndex and the calling command's VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00637)~^~ VALIDATION_ERROR_0c6004fc~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-allocationSize-00638~^~core~^~The spec valid usage text states 'allocationSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00638)~^~ -VALIDATION_ERROR_0c6004fe~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-pNext-00639~^~(VK_KHX_external_memory+VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfoKHX, and any of the handle types specified in VkExportMemoryAllocateInfoKHX::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2KHR in VkExternalImageFormatPropertiesKHX::externalMemoryProperties::externalMemoryFeatures or VkExternalBufferPropertiesKHX::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationMemoryAllocateInfoNV with either its image or buffer field set to a value other than VK_NULL_HANDLE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00639)~^~ -VALIDATION_ERROR_0c600500~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-pNext-00640~^~(VK_KHX_external_memory+VK_NV_external_memory)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfoKHX, it must not contain an instance of VkExportMemoryAllocateInfoNV or VkExportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00640)~^~ -VALIDATION_ERROR_0c600502~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-pNext-00641~^~(VK_KHX_external_memory_win32+VK_NV_external_memory_win32)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkImportMemoryWin32HandleInfoKHX, it must not contain an instance of VkImportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00641)~^~ -VALIDATION_ERROR_0c600504~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-allocationSize-00642~^~(VK_KHX_external_memory_win32,VK_KHX_external_memory_fd)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00642)~^~ -VALIDATION_ERROR_0c600506~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-None-00643~^~(VK_KHX_external_memory+VK_KHX_device_group)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by VkMemoryAllocateFlagsInfoKHX must match that specified when the memory object being imported was allocated.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-00643)~^~ -VALIDATION_ERROR_0c600508~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-None-00644~^~(VK_KHX_external_memory+VK_KHX_device_group)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to vkAllocateMemory must match the list of physical devices that comprise the logical device on which the memory was originally allocated.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-00644)~^~ -VALIDATION_ERROR_0c60050a~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645~^~(VK_KHX_external_memory_win32)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryWin32HandlePropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645)~^~ -VALIDATION_ERROR_0c60050c~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-allocationSize-00646~^~(VK_KHX_external_memory_win32)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX, allocationSize must match the size reported in the memory requirements of the image or buffer member of the instance of VkDedicatedAllocationMemoryAllocateInfoNV included in the pNext chain.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00646)~^~ -VALIDATION_ERROR_0c60050e~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-allocationSize-00647~^~(VK_KHX_external_memory_win32)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX, allocationSize must match the size specified when creating the Direct3D 12 heap from which the external handle was extracted.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00647)~^~ -VALIDATION_ERROR_0c600510~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648~^~(VK_KHX_external_memory_fd)~^~The spec valid usage text states 'If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryFdPropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648)~^~ -VALIDATION_ERROR_0c61c40d~^~Y~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-pNext-pNext~^~core~^~The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationMemoryAllocateInfoNV or VkMemoryAllocateFlagsInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-pNext)~^~implicit +VALIDATION_ERROR_0c6004fe~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-pNext-00639~^~(VK_KHR_external_memory)+(VK_KHR_dedicated_allocation,VK_NV_dedicated_allocation)~^~The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfoKHR, and any of the handle types specified in VkExportMemoryAllocateInfoKHR::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2KHR in VkExternalImageFormatPropertiesKHR::externalMemoryProperties::externalMemoryFeatures or VkExternalBufferPropertiesKHR::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00639)~^~ +VALIDATION_ERROR_0c600500~^~N~^~Unknown~^~vkAllocateMemory~^~VUID-VkMemoryAllocateInfo-pNext-00640~^~(VK_KHR_external_memory)+(VK_KHR_dedicated_allocation,VK_NV_dedicated_allocation)+(VK_KHR_dedicated_allocation[VkMemoryDedicatedAllocateInfoKHRVkMemoryDedicatedAllocateInfoKHRVkMemoryDedicatedAllocateInfoKHRVkMemoryDedicatedAllocateInfoKHRVkMemoryDedicatedAllocateInfoKHRVkMemoryDedicatedAllocateInfoKHRVkMemoryDedicatedAllocateInfoKHRVkMemoryDedicatedAllocateInfoKHRVkMemoryDedicatedAllocateInfoKHR validation_error_map{ {VALIDATION_ERROR_01400728, "The spec valid usage text states 'If the sparse buffer residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00916)"}, {VALIDATION_ERROR_0140072a, "The spec valid usage text states 'If the sparse aliased residency feature is not enabled, flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00917)"}, {VALIDATION_ERROR_0140072c, "The spec valid usage text states 'If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-00918)"}, - {VALIDATION_ERROR_0140072e, "The spec valid usage text states 'If any of the handle types specified in VkExternalMemoryImageCreateInfoKHX::handleTypes requires dedicated allocation, as reported by vkGetPhysicalDeviceExternalBufferPropertiesKHX in VkExternalBufferPropertiesKHX::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationBufferCreateInfoNV with its dedicatedAllocation field set to VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-handleTypes-00919)"}, - {VALIDATION_ERROR_01400730, "The spec valid usage text states 'If the pNext extension contains an instance of VkExternalMemoryBufferCreateInfoKHX, its handleTypes member must only contain bits that are also in VkExternalBufferPropertiesKHX::externalMemoryProperties.pname:compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferPropertiesKHX with pExternalBufferInfo->handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfoKHX::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-00920)"}, + {VALIDATION_ERROR_0140072e, "The spec valid usage text states 'If any of the handle types specified in VkExternalMemoryImageCreateInfoKHR::handleTypes requires dedicated allocation, as reported by vkGetPhysicalDeviceExternalBufferPropertiesKHR in VkExternalBufferPropertiesKHR::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationBufferCreateInfoNV with its dedicatedAllocation field set to VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-handleTypes-00919)"}, + {VALIDATION_ERROR_01400730, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryBufferCreateInfoKHR, its handleTypes member must only contain bits that are also in VkExternalBufferPropertiesKHR::externalMemoryProperties.pname:compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferPropertiesKHR with pExternalBufferInfo->handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfoKHR::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-00920)"}, {VALIDATION_ERROR_01400ade, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-01391)"}, {VALIDATION_ERROR_01400b16, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2KHR for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-01419)"}, {VALIDATION_ERROR_01409001, "The spec valid usage text states 'flags must be a valid combination of VkBufferCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_0141c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDedicatedAllocationBufferCreateInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_0141c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationBufferCreateInfoNV or VkExternalMemoryBufferCreateInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_0142b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sType-sType)"}, + {VALIDATION_ERROR_0142b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sType-unique)"}, {VALIDATION_ERROR_0142c001, "The spec valid usage text states 'sharingMode must be a valid VkSharingMode value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-sharingMode-parameter)"}, {VALIDATION_ERROR_01430601, "The spec valid usage text states 'usage must be a valid combination of VkBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-usage-parameter)"}, {VALIDATION_ERROR_01430603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferCreateInfo-usage-requiredbitmask)"}, @@ -3360,10 +3494,10 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0180094e, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01191)"}, {VALIDATION_ERROR_01800950, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01192)"}, {VALIDATION_ERROR_01800952, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01193)"}, - {VALIDATION_ERROR_01800954, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHX (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01194)"}, - {VALIDATION_ERROR_01800956, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHX (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01195)"}, + {VALIDATION_ERROR_01800954, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHR (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01194)"}, + {VALIDATION_ERROR_01800956, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHR (see Queue Family Properties)' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01195)"}, {VALIDATION_ERROR_01800958, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01196)"}, - {VALIDATION_ERROR_01800ac8, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or VK_QUEUE_FAMILY_EXTERNAL_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01380)"}, + {VALIDATION_ERROR_01800ac8, "The spec valid usage text states 'If buffer was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or VK_QUEUE_FAMILY_EXTERNAL_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-01380)"}, {VALIDATION_ERROR_01801a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-buffer-parameter)"}, {VALIDATION_ERROR_01806801, "The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-dstAccessMask-parameter)"}, {VALIDATION_ERROR_0181c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryBarrier-pNext-pNext)"}, @@ -3465,11 +3599,11 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0321c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-pNext-pNext)"}, {VALIDATION_ERROR_0322b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-sType-sType)"}, {VALIDATION_ERROR_0322d201, "The spec valid usage text states 'srcSet must be a valid VkDescriptorSet handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkCopyDescriptorSet-srcSet-parameter)"}, - {VALIDATION_ERROR_0340009e, "The spec valid usage text states 'waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where SubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHX structure.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-waitSemaphoreValuesCount-00079)"}, - {VALIDATION_ERROR_034000a0, "The spec valid usage text states 'signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where SubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHX structure.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-signalSemaphoreValuesCount-00080)"}, - {VALIDATION_ERROR_03423201, "The spec valid usage text states 'If signalSemaphoreValuesCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a pointer to an array of signalSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-pSignalSemaphoreValues-parameter)"}, - {VALIDATION_ERROR_03427401, "The spec valid usage text states 'If waitSemaphoreValuesCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a pointer to an array of waitSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-pWaitSemaphoreValues-parameter)"}, - {VALIDATION_ERROR_0342b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHX-sType-sType)"}, + {VALIDATION_ERROR_0340009e, "The spec valid usage text states 'waitSemaphoreValuesCount must be the same value as VkSubmitInfo::waitSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-waitSemaphoreValuesCount-00079)"}, + {VALIDATION_ERROR_034000a0, "The spec valid usage text states 'signalSemaphoreValuesCount must be the same value as VkSubmitInfo::signalSemaphoreCount, where VkSubmitInfo is in the pNext chain of this VkD3D12FenceSubmitInfoKHR structure.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-signalSemaphoreValuesCount-00080)"}, + {VALIDATION_ERROR_03423201, "The spec valid usage text states 'If signalSemaphoreValuesCount is not 0, and pSignalSemaphoreValues is not NULL, pSignalSemaphoreValues must be a pointer to an array of signalSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-pSignalSemaphoreValues-parameter)"}, + {VALIDATION_ERROR_03427401, "The spec valid usage text states 'If waitSemaphoreValuesCount is not 0, and pWaitSemaphoreValues is not NULL, pWaitSemaphoreValues must be a pointer to an array of waitSemaphoreValuesCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-pWaitSemaphoreValues-parameter)"}, + {VALIDATION_ERROR_0342b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkD3D12FenceSubmitInfoKHR-sType-sType)"}, {VALIDATION_ERROR_0361a801, "The spec valid usage text states 'pMarkerName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-pMarkerName-parameter)"}, {VALIDATION_ERROR_0361c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-pNext-pNext)"}, {VALIDATION_ERROR_0362b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDebugMarkerMarkerInfoEXT-sType-sType)"}, @@ -3557,7 +3691,7 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_056002ec, "The spec valid usage text states 'ppEnabledExtensionNames must not contain both VK_KHR_maintenance1 and VK_AMD_negative_viewport_height' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374)"}, {VALIDATION_ERROR_05609005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-flags-zerobitmask)"}, {VALIDATION_ERROR_05615a01, "The spec valid usage text states 'If pEnabledFeatures is not NULL, pEnabledFeatures must be a pointer to a valid VkPhysicalDeviceFeatures structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter)"}, - {VALIDATION_ERROR_0561c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceFeatures2KHR, VkPhysicalDeviceMultiviewFeaturesKHX, or VkDeviceGroupDeviceCreateInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_0561c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceFeatures2KHR, VkPhysicalDevice16BitStorageFeaturesKHR, VkPhysicalDeviceVariablePointerFeaturesKHR, VkPhysicalDeviceMultiviewFeaturesKHX, or VkDeviceGroupDeviceCreateInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_0561fe01, "The spec valid usage text states 'pQueueCreateInfos must be a pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter)"}, {VALIDATION_ERROR_05628e01, "The spec valid usage text states 'If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a pointer to an array of enabledExtensionCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter)"}, {VALIDATION_ERROR_05629001, "The spec valid usage text states 'If enabledLayerCount is not 0, ppEnabledLayerNames must be a pointer to an array of enabledLayerCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter)"}, @@ -3655,41 +3789,42 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_07e09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-flags-zerobitmask)"}, {VALIDATION_ERROR_07e1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_07e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkEventCreateInfo-sType-sType)"}, - {VALIDATION_ERROR_08000520, "The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatPropertiesKHX or VkExternalBufferPropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHX-handleTypes-00656)"}, - {VALIDATION_ERROR_08009e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHX-handleTypes-parameter)"}, - {VALIDATION_ERROR_0801c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_0802b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHX-sType-sType)"}, + {VALIDATION_ERROR_08000520, "The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalImageFormatPropertiesKHR or VkExternalBufferPropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHR-handleTypes-00656)"}, + {VALIDATION_ERROR_08009e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHR-handleTypes-parameter)"}, + {VALIDATION_ERROR_0801c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_0802b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoKHR-sType-sType)"}, {VALIDATION_ERROR_08209e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter)"}, {VALIDATION_ERROR_0821c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-pNext-pNext)"}, {VALIDATION_ERROR_0822b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryAllocateInfoNV-sType-sType)"}, - {VALIDATION_ERROR_08400522, "The spec valid usage text states 'If VkExportMemoryAllocateInfoKHX::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX, VkExportMemoryWin32HandleInfoKHX must not be in the pNext chain of VkMemoryAllocateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHX-handleTypes-00657)"}, - {VALIDATION_ERROR_0840f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHX-pAttributes-parameter)"}, - {VALIDATION_ERROR_0841c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_0842b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHX-sType-sType)"}, + {VALIDATION_ERROR_08400522, "The spec valid usage text states 'If VkExportMemoryAllocateInfoKHR::handleTypes does not include VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR, VkExportMemoryWin32HandleInfoKHR must not be in the pNext chain of VkMemoryAllocateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-handleTypes-00657)"}, + {VALIDATION_ERROR_0840f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-pAttributes-parameter)"}, + {VALIDATION_ERROR_0841c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_0842b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoKHR-sType-sType)"}, {VALIDATION_ERROR_0860f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-pAttributes-parameter)"}, {VALIDATION_ERROR_0861c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-pNext-pNext)"}, {VALIDATION_ERROR_0862b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportMemoryWin32HandleInfoNV-sType-sType)"}, - {VALIDATION_ERROR_088008c8, "The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphorePropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHX-handleTypes-01124)"}, - {VALIDATION_ERROR_08809e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHX-handleTypes-parameter)"}, - {VALIDATION_ERROR_0881c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_0882b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHX-sType-sType)"}, - {VALIDATION_ERROR_08a008ca, "The spec valid usage text states 'If VkExportSemaphoreCreateInfoKHX::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX, VkExportSemaphoreWin32HandleInfoKHX must not be in the pNext chain of VkSemaphoreCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHX-handleTypes-01125)"}, - {VALIDATION_ERROR_08a0f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHX-pAttributes-parameter)"}, - {VALIDATION_ERROR_08a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_08a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHX-sType-sType)"}, - {VALIDATION_ERROR_08c09e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHX-handleTypes-parameter)"}, - {VALIDATION_ERROR_08c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_08c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHX-sType-sType)"}, - {VALIDATION_ERROR_08e09e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHX-handleTypes-parameter)"}, - {VALIDATION_ERROR_08e09e03, "The spec valid usage text states 'handleTypes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHX-handleTypes-requiredbitmask)"}, - {VALIDATION_ERROR_08e1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_08e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHX-sType-sType)"}, + {VALIDATION_ERROR_088008c8, "The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalSemaphorePropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHR-handleTypes-01124)"}, + {VALIDATION_ERROR_08809e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalSemaphoreHandleTypeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHR-handleTypes-parameter)"}, + {VALIDATION_ERROR_0881c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_0882b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreCreateInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_08a008ca, "The spec valid usage text states 'If VkExportSemaphoreCreateInfoKHR::handleTypes does not include VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, VkExportSemaphoreWin32HandleInfoKHR must not be in the pNext chain of VkSemaphoreCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-handleTypes-01125)"}, + {VALIDATION_ERROR_08a0f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-pAttributes-parameter)"}, + {VALIDATION_ERROR_08a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_08a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportSemaphoreWin32HandleInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_08c09e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHR-handleTypes-parameter)"}, + {VALIDATION_ERROR_08c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_08c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryBufferCreateInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_08e09e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHR-handleTypes-parameter)"}, + {VALIDATION_ERROR_08e09e03, "The spec valid usage text states 'handleTypes must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHR-handleTypes-requiredbitmask)"}, + {VALIDATION_ERROR_08e1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_08e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoKHR-sType-sType)"}, {VALIDATION_ERROR_09009e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter)"}, {VALIDATION_ERROR_0901c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-pNext-pNext)"}, {VALIDATION_ERROR_0902b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalMemoryImageCreateInfoNV-sType-sType)"}, {VALIDATION_ERROR_09209001, "The spec valid usage text states 'flags must be a valid combination of VkFenceCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-flags-parameter)"}, - {VALIDATION_ERROR_0921c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_0921c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportFenceCreateInfoKHR or VkExportFenceWin32HandleInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_0922b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-sType-sType)"}, + {VALIDATION_ERROR_0922b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceCreateInfo-sType-unique)"}, {VALIDATION_ERROR_09400009, "The spec valid usage text states 'Both of renderPass, and the elements of pAttachments that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-commonparent)"}, {VALIDATION_ERROR_094006d8, "The spec valid usage text states 'attachmentCount must be equal to the attachment count specified in renderPass' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-attachmentCount-00876)"}, {VALIDATION_ERROR_094006da, "The spec valid usage text states 'Any given element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00877)"}, @@ -3762,7 +3897,7 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0960be01, "The spec valid usage text states 'layout must be a valid VkPipelineLayout handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-parameter)"}, {VALIDATION_ERROR_09615601, "The spec valid usage text states 'If pDynamicState is not NULL, pDynamicState must be a pointer to a valid VkPipelineDynamicStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter)"}, {VALIDATION_ERROR_09619801, "The spec valid usage text states 'pInputAssemblyState must be a pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pInputAssemblyState-parameter)"}, - {VALIDATION_ERROR_0961c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_0961c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineDiscardRectangleStateCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_09620801, "The spec valid usage text states 'pRasterizationState must be a pointer to a valid VkPipelineRasterizationStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter)"}, {VALIDATION_ERROR_09623e01, "The spec valid usage text states 'pStages must be a pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-parameter)"}, {VALIDATION_ERROR_09626801, "The spec valid usage text states 'pVertexInputState must be a pointer to a valid VkPipelineVertexInputStateCreateInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pVertexInputState-parameter)"}, @@ -3869,20 +4004,21 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_09e007b2, "The spec valid usage text states 'If tiling is VK_IMAGE_TILING_OPTIMAL, and VkFormatProperties::optimalTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, usage must not contain VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-tiling-00985)"}, {VALIDATION_ERROR_09e007b4, "The spec valid usage text states 'If tiling is VK_IMAGE_TILING_OPTIMAL, and VkFormatProperties::optimalTilingFeatures (as returned by vkGetPhysicalDeviceFormatProperties with the same value of format) does not include VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, usage must not contain VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-tiling-00986)"}, {VALIDATION_ERROR_09e007b6, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-00987)"}, - {VALIDATION_ERROR_09e007b8, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, it must not contain an instance of VkExternalMemoryImageCreateInfoKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00988)"}, - {VALIDATION_ERROR_09e007ba, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoKHX, and any of the handle types specified in VkExternalMemoryImageCreateInfoKHX::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2KHR in VkExternalImageFormatPropertiesKHX::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationImageCreateInfoNV with its dedicatedAllocation field set to VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00989)"}, - {VALIDATION_ERROR_09e007bc, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoKHX, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesKHX::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2KHR with format, type, tiling, usage, and flags equal to those in this structure, and with an instance of VkPhysicalDeviceExternalImageFormatInfoKHX in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoKHX::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00990)"}, + {VALIDATION_ERROR_09e007b8, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, it must not contain an instance of VkExternalMemoryImageCreateInfoKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00988)"}, + {VALIDATION_ERROR_09e007ba, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoKHR, and any of the handle types specified in VkExternalMemoryImageCreateInfoKHR::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2KHR in VkExternalImageFormatPropertiesKHR::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationImageCreateInfoNV with its dedicatedAllocation field set to VK_TRUE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00989)"}, + {VALIDATION_ERROR_09e007bc, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoKHR, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesKHR::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceImageFormatProperties2KHR with format, type, tiling, usage, and flags equal to those in this structure, and with an instance of VkPhysicalDeviceExternalImageFormatInfoKHR in the pNext chain, with a handleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoKHR::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00990)"}, {VALIDATION_ERROR_09e007be, "The spec valid usage text states 'If the pNext chain contains an instance of VkExternalMemoryImageCreateInfoNV, its handleTypes member must only contain bits that are also in VkExternalImageFormatPropertiesNV::externalMemoryProperties::compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalImageFormatPropertiesNV with format, type, tiling, usage, and flags equal to those in this structure, and with externalHandleType equal to any one of the handle types specified in VkExternalMemoryImageCreateInfoNV::handleTypes' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-00991)"}, - {VALIDATION_ERROR_09e007c0, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_BIND_SFR_BIT_KHX, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D, and tiling must be VK_IMAGE_TILING_OPTIMAL.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-00992)"}, + {VALIDATION_ERROR_09e007c0, "The spec valid usage text states 'If flags contains VK_IMAGE_CREATE_BIND_SFR_BIT_KHX, then mipLevels must be one, arrayLayers must be one, imageType must be VK_IMAGE_TYPE_2D, and tiling must be VK_IMAGE_TILING_OPTIMAL' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-flags-00992)"}, {VALIDATION_ERROR_09e007c2, "The spec valid usage text states 'initialLayout must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-initialLayout-00993)"}, {VALIDATION_ERROR_09e00ae0, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-01392)"}, {VALIDATION_ERROR_09e00b18, "The spec valid usage text states 'If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties or vkGetPhysicalDeviceQueueFamilyProperties2KHR for the physicalDevice that was used to create device' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-sharingMode-01420)"}, {VALIDATION_ERROR_09e00b1a, "The spec valid usage text states 'If the logical device was created with VkDeviceGroupDeviceCreateInfoKHX::physicalDeviceCount equal to 1, flags must not contain VK_IMAGE_CREATE_BIND_SFR_BIT_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-physicalDeviceCount-01421)"}, + {VALIDATION_ERROR_09e00b46, "The spec valid usage text states 'If the pNext chain includes a' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageCreateInfo-pNext-01443)"}, {VALIDATION_ERROR_09e09001, "The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-flags-parameter)"}, {VALIDATION_ERROR_09e09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-format-parameter)"}, {VALIDATION_ERROR_09e0ac01, "The spec valid usage text states 'imageType must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-imageType-parameter)"}, {VALIDATION_ERROR_09e0b801, "The spec valid usage text states 'initialLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-initialLayout-parameter)"}, - {VALIDATION_ERROR_09e1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationImageCreateInfoNV or VkImageSwapchainCreateInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_09e1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationImageCreateInfoNV, VkImageSwapchainCreateInfoKHX, VkExternalMemoryImageCreateInfoKHR, or VkExternalMemoryImageCreateInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_09e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sType-sType)"}, {VALIDATION_ERROR_09e2b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-sType-unique)"}, {VALIDATION_ERROR_09e2b401, "The spec valid usage text states 'samples must be a valid VkSampleCountFlagBits value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageCreateInfo-samples-parameter)"}, @@ -3895,8 +4031,8 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0a00095e, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, srcQueueFamilyIndex and dstQueueFamilyIndex must both be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01199)"}, {VALIDATION_ERROR_0a000960, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, srcQueueFamilyIndex and dstQueueFamilyIndex must either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01200)"}, {VALIDATION_ERROR_0a000962, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex must also be VK_QUEUE_FAMILY_IGNORED.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01201)"}, - {VALIDATION_ERROR_0a000964, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHX (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01202)"}, - {VALIDATION_ERROR_0a000966, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHX (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01203)"}, + {VALIDATION_ERROR_0a000964, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and srcQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHR (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01202)"}, + {VALIDATION_ERROR_0a000966, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE and dstQueueFamilyIndex is not VK_QUEUE_FAMILY_IGNORED, it must be a valid queue family or VK_QUEUE_FAMILY_EXTERNAL_KHR (see Queue Family Properties).' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01203)"}, {VALIDATION_ERROR_0a00096a, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not VK_QUEUE_FAMILY_IGNORED, at least one of them must be the same as the family of the queue that will execute this barrier' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01205)"}, {VALIDATION_ERROR_0a00096c, "The spec valid usage text states 'subresourceRange must be a valid image subresource range for the image (see Image Views)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-subresourceRange-01206)"}, {VALIDATION_ERROR_0a00096e, "The spec valid usage text states 'If image has a depth/stencil format with both depth and stencil components, then aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01207)"}, @@ -3907,7 +4043,7 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0a000978, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01212)"}, {VALIDATION_ERROR_0a00097a, "The spec valid usage text states 'If either oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT set' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-oldLayout-01213)"}, {VALIDATION_ERROR_0a000aca, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, at least one of srcQueueFamilyIndex and dstQueueFamilyIndex must be VK_QUEUE_FAMILY_IGNORED' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01381)"}, - {VALIDATION_ERROR_0a000acc, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or VK_QUEUE_FAMILY_EXTERNAL_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01382)"}, + {VALIDATION_ERROR_0a000acc, "The spec valid usage text states 'If image was created with a sharing mode of VK_SHARING_MODE_CONCURRENT, and one of srcQueueFamilyIndex and dstQueueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, the other must be VK_QUEUE_FAMILY_IGNORED or VK_QUEUE_FAMILY_EXTERNAL_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkImageMemoryBarrier-image-01382)"}, {VALIDATION_ERROR_0a006801, "The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-dstAccessMask-parameter)"}, {VALIDATION_ERROR_0a00a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-image-parameter)"}, {VALIDATION_ERROR_0a00d401, "The spec valid usage text states 'newLayout must be a valid VkImageLayout value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryBarrier-newLayout-parameter)"}, @@ -3958,12 +4094,12 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0ac007e0, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01008)"}, {VALIDATION_ERROR_0ac007e2, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01009)"}, {VALIDATION_ERROR_0ac007e4, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01010)"}, - {VALIDATION_ERROR_0ac007e6, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage containing VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01011)"}, + {VALIDATION_ERROR_0ac007e6, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_LINEAR and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01011)"}, {VALIDATION_ERROR_0ac007e8, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL, format must be format that has at least one supported feature bit present in the value of VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01012)"}, {VALIDATION_ERROR_0ac007ea, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, format must be supported for sampled images, as specified by the VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01013)"}, {VALIDATION_ERROR_0ac007ec, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_STORAGE_BIT, format must be supported for storage images, as specified by the VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01014)"}, {VALIDATION_ERROR_0ac007ee, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, format must be supported for color attachments, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01015)"}, - {VALIDATION_ERROR_0ac007f0, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage containing VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01016)"}, + {VALIDATION_ERROR_0ac007f0, "The spec valid usage text states 'If image was created with VK_IMAGE_TILING_OPTIMAL and usage contains VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, format must be supported for depth/stencil attachments, as specified by the VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties with the same value of format' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01016)"}, {VALIDATION_ERROR_0ac007f2, "The spec valid usage text states 'subresourceRange must be a valid image subresource range for image (see Image Views)' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-01017)"}, {VALIDATION_ERROR_0ac007f4, "The spec valid usage text states 'If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be compatible with the format used to create image, as defined in Format Compatibility Classes' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01018)"}, {VALIDATION_ERROR_0ac007f6, "The spec valid usage text states 'If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, format must be identical to the format used to create image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-image-01019)"}, @@ -3977,38 +4113,47 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0ac2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-sType-sType)"}, {VALIDATION_ERROR_0ac2ea01, "The spec valid usage text states 'subresourceRange must be a valid VkImageSubresourceRange structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-subresourceRange-parameter)"}, {VALIDATION_ERROR_0ac30801, "The spec valid usage text states 'viewType must be a valid VkImageViewType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageViewCreateInfo-viewType-parameter)"}, - {VALIDATION_ERROR_0ae00536, "The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatPropertiesKHX or VkExternalBufferPropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-handleType-00667)"}, - {VALIDATION_ERROR_0ae00538, "The spec valid usage text states 'The memory from which fd was exported must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-fd-00668)"}, - {VALIDATION_ERROR_0ae0053a, "The spec valid usage text states 'If handleType is not 0, it must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-handleType-00669)"}, - {VALIDATION_ERROR_0ae0053c, "The spec valid usage text states 'If handleType is not 0, fd must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-handleType-00670)"}, - {VALIDATION_ERROR_0ae09c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-handleType-parameter)"}, - {VALIDATION_ERROR_0ae1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_0ae2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHX-sType-sType)"}, - {VALIDATION_ERROR_0b000524, "The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatPropertiesKHX or VkExternalBufferPropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handleType-00658)"}, - {VALIDATION_ERROR_0b000526, "The spec valid usage text states 'The memory from which handle was exported must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handle-00659)"}, - {VALIDATION_ERROR_0b000528, "The spec valid usage text states 'If handleType is not 0, it must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handleType-00660)"}, - {VALIDATION_ERROR_0b00052a, "The spec valid usage text states 'If handleType is not 0, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handleType-00661)"}, - {VALIDATION_ERROR_0b009c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-handleType-parameter)"}, - {VALIDATION_ERROR_0b01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_0b02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHX-sType-sType)"}, + {VALIDATION_ERROR_0ae00536, "The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatPropertiesKHR or VkExternalBufferPropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00667)"}, + {VALIDATION_ERROR_0ae00538, "The spec valid usage text states 'The memory from which fd was exported must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-fd-00668)"}, + {VALIDATION_ERROR_0ae0053a, "The spec valid usage text states 'If handleType is not 0, it must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00669)"}, + {VALIDATION_ERROR_0ae0053c, "The spec valid usage text states 'If handleType is not 0, fd must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00670)"}, + {VALIDATION_ERROR_0ae09c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_0ae1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_0ae2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_0b000524, "The spec valid usage text states 'If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatPropertiesKHR or VkExternalBufferPropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00658)"}, + {VALIDATION_ERROR_0b000526, "The spec valid usage text states 'The memory from which handle was exported, or the memory named by name must have been created on the same underlying physical device as device.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-00659)"}, + {VALIDATION_ERROR_0b000528, "The spec valid usage text states 'If handleType is not 0, it must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00660)"}, + {VALIDATION_ERROR_0b00052a, "The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-00661)"}, + {VALIDATION_ERROR_0b000b3e, "The spec valid usage text states 'If handleType is not VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01439)"}, + {VALIDATION_ERROR_0b000b40, "The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid memory resource of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-01440)"}, + {VALIDATION_ERROR_0b000b42, "The spec valid usage text states 'if handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handle-01441)"}, + {VALIDATION_ERROR_0b009c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_0b01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_0b02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoKHR-sType-sType)"}, {VALIDATION_ERROR_0b200a5e, "The spec valid usage text states 'handleType must not have more than one bit set.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-01327)"}, {VALIDATION_ERROR_0b200a60, "The spec valid usage text states 'handle must be a valid handle to memory, obtained as specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handle-01328)"}, {VALIDATION_ERROR_0b209c01, "The spec valid usage text states 'handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter)"}, {VALIDATION_ERROR_0b21c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-pNext-pNext)"}, {VALIDATION_ERROR_0b22b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportMemoryWin32HandleInfoNV-sType-sType)"}, - {VALIDATION_ERROR_0b4008ee, "The spec valid usage text states 'handleType must be a value included in the Handle Type Permanence for VkImportSemaphoreFdInfoKHX table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-handleType-01143)"}, - {VALIDATION_ERROR_0b4008f0, "The spec valid usage text states 'The semaphore from which handleType was exported must have been created on the same underlying physical device as semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-handleType-01144)"}, - {VALIDATION_ERROR_0b409c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-handleType-parameter)"}, - {VALIDATION_ERROR_0b41c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_0b42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-sType-sType)"}, - {VALIDATION_ERROR_0b42b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHX-semaphore-parameter)"}, - {VALIDATION_ERROR_0b6008e8, "The spec valid usage text states 'handleType must be a value included in the Handle Type Permanence for VkImportSemaphoreWin32HandleInfoKHX table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-01140)"}, - {VALIDATION_ERROR_0b6008ea, "The spec valid usage text states 'The semaphore from which handleType was exported must have been created on the same underlying physical device as semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-01141)"}, - {VALIDATION_ERROR_0b609c01, "The spec valid usage text states 'handleType must be a valid combination of VkExternalSemaphoreHandleTypeFlagBitsKHX values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-parameter)"}, - {VALIDATION_ERROR_0b609c03, "The spec valid usage text states 'handleType must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-handleType-requiredbitmask)"}, - {VALIDATION_ERROR_0b61c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_0b62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-sType-sType)"}, - {VALIDATION_ERROR_0b62b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHX-semaphore-parameter)"}, + {VALIDATION_ERROR_0b4008ee, "The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportSemaphoreFdInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-01143)"}, + {VALIDATION_ERROR_0b4008f0, "The spec valid usage text states 'The semaphore from which handleType was exported must have been created on the same underlying physical device as semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-01144)"}, + {VALIDATION_ERROR_0b409001, "The spec valid usage text states 'flags must be a valid combination of VkSemaphoreImportFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-flags-parameter)"}, + {VALIDATION_ERROR_0b409c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_0b41c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_0b42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_0b42b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter)"}, + {VALIDATION_ERROR_0b6008e8, "The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportSemaphoreWin32HandleInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01140)"}, + {VALIDATION_ERROR_0b6008ea, "The spec valid usage text states 'The semaphore from which handleType or name was exported must have been created on the same underlying physical device as semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01141)"}, + {VALIDATION_ERROR_0b600b74, "The spec valid usage text states 'If handleType is not VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR or VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01466)"}, + {VALIDATION_ERROR_0b600b76, "The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01467)"}, + {VALIDATION_ERROR_0b600b78, "The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-01468)"}, + {VALIDATION_ERROR_0b600b7a, "The spec valid usage text states 'If handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handle-01469)"}, + {VALIDATION_ERROR_0b609001, "The spec valid usage text states 'flags must be a valid combination of VkSemaphoreImportFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter)"}, + {VALIDATION_ERROR_0b609c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_0b609c03, "The spec valid usage text states 'handleType must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-requiredbitmask)"}, + {VALIDATION_ERROR_0b61c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_0b62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_0b62b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter)"}, {VALIDATION_ERROR_0b800a86, "The spec valid usage text states 'tokenCount must be greater than 0 and below VkDeviceGeneratedCommandsLimitsNVX::maxIndirectCommandsLayoutTokenCount' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-01347)"}, {VALIDATION_ERROR_0b800a88, "The spec valid usage text states 'If the VkDeviceGeneratedCommandsFeaturesNVX::computeBindingPointSupport feature is not enabled, then pipelineBindPoint must not be VK_PIPELINE_BIND_POINT_COMPUTE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-computeBindingPointSupport-01348)"}, {VALIDATION_ERROR_0b800a8a, "The spec valid usage text states 'If pTokens contains an entry of VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX it must be the first element of the array and there must be only a single element of such token type.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-01349)"}, @@ -4031,10 +4176,11 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0bc2fe01, "The spec valid usage text states 'tokenType must be a valid VkIndirectCommandsTokenTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkIndirectCommandsTokenNVX-tokenType-parameter)"}, {VALIDATION_ERROR_0be09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-flags-zerobitmask)"}, {VALIDATION_ERROR_0be0ee01, "The spec valid usage text states 'If pApplicationInfo is not NULL, pApplicationInfo must be a pointer to a valid VkApplicationInfo structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pApplicationInfo-parameter)"}, - {VALIDATION_ERROR_0be1c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_0be1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDebugReportCallbackCreateInfoEXT or VkValidationFlagsEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_0be28e01, "The spec valid usage text states 'If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a pointer to an array of enabledExtensionCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-ppEnabledExtensionNames-parameter)"}, {VALIDATION_ERROR_0be29001, "The spec valid usage text states 'If enabledLayerCount is not 0, ppEnabledLayerNames must be a pointer to an array of enabledLayerCount null-terminated UTF-8 strings' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-ppEnabledLayerNames-parameter)"}, {VALIDATION_ERROR_0be2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-sType-sType)"}, + {VALIDATION_ERROR_0be2b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkInstanceCreateInfo-sType-unique)"}, {VALIDATION_ERROR_0c000a4a, "The spec valid usage text states 'pView must be a valid NSView and must be backed by a CALayer instance of type CAMetalLayer.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-pView-01317)"}, {VALIDATION_ERROR_0c009005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-flags-zerobitmask)"}, {VALIDATION_ERROR_0c01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMacOSSurfaceCreateInfoMVK-pNext-pNext)"}, @@ -4056,17 +4202,17 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0c42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateFlagsInfoKHX-sType-sType)"}, {VALIDATION_ERROR_0c6004fa, "The spec valid usage text states 'allocationSize must be less than or equal to the amount of memory available to the VkMemoryHeap specified by memoryTypeIndex and the calling command's VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00637)"}, {VALIDATION_ERROR_0c6004fc, "The spec valid usage text states 'allocationSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00638)"}, - {VALIDATION_ERROR_0c6004fe, "The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfoKHX, and any of the handle types specified in VkExportMemoryAllocateInfoKHX::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2KHR in VkExternalImageFormatPropertiesKHX::externalMemoryProperties::externalMemoryFeatures or VkExternalBufferPropertiesKHX::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of VkDedicatedAllocationMemoryAllocateInfoNV with either its image or buffer field set to a value other than VK_NULL_HANDLE.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00639)"}, - {VALIDATION_ERROR_0c600500, "The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfoKHX, it must not contain an instance of VkExportMemoryAllocateInfoNV or VkExportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00640)"}, - {VALIDATION_ERROR_0c600502, "The spec valid usage text states 'If the pNext chain contains an instance of VkImportMemoryWin32HandleInfoKHX, it must not contain an instance of VkImportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00641)"}, + {VALIDATION_ERROR_0c6004fe, "The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfoKHR, and any of the handle types specified in VkExportMemoryAllocateInfoKHR::handleTypes require a dedicated allocation, as reported by vkGetPhysicalDeviceImageFormatProperties2KHR in VkExternalImageFormatPropertiesKHR::externalMemoryProperties::externalMemoryFeatures or VkExternalBufferPropertiesKHR::externalMemoryProperties::externalMemoryFeatures, the pNext chain must contain an instance of' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00639)"}, + {VALIDATION_ERROR_0c600500, "The spec valid usage text states 'If the pNext chain contains an instance of VkExportMemoryAllocateInfoKHR, it must not contain an instance of VkExportMemoryAllocateInfoNV or VkExportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00640)"}, + {VALIDATION_ERROR_0c600502, "The spec valid usage text states 'If the pNext chain contains an instance of VkImportMemoryWin32HandleInfoKHR, it must not contain an instance of VkImportMemoryWin32HandleInfoNV.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-00641)"}, {VALIDATION_ERROR_0c600504, "The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the values of allocationSize and memoryTypeIndex must match those specified when the memory object being imported was created.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00642)"}, {VALIDATION_ERROR_0c600506, "The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the device mask specified by VkMemoryAllocateFlagsInfoKHX must match that specified when the memory object being imported was allocated.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-00643)"}, {VALIDATION_ERROR_0c600508, "The spec valid usage text states 'If the parameters define an import operation and the external handle specified was created by the Vulkan API, the list of physical devices that comprise the logical device passed to vkAllocateMemory must match the list of physical devices that comprise the logical device on which the memory was originally allocated.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-None-00644)"}, - {VALIDATION_ERROR_0c60050a, "The spec valid usage text states 'If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryWin32HandlePropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645)"}, - {VALIDATION_ERROR_0c60050c, "The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX, allocationSize must match the size reported in the memory requirements of the image or buffer member of the instance of VkDedicatedAllocationMemoryAllocateInfoNV included in the pNext chain.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00646)"}, - {VALIDATION_ERROR_0c60050e, "The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX, allocationSize must match the size specified when creating the Direct3D 12 heap from which the external handle was extracted.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00647)"}, - {VALIDATION_ERROR_0c600510, "The spec valid usage text states 'If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryFdPropertiesKHX.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648)"}, - {VALIDATION_ERROR_0c61c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationMemoryAllocateInfoNV or VkMemoryAllocateFlagsInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_0c60050a, "The spec valid usage text states 'If the parameters define an import operation and the external handle is an NT handle or a global share handle created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryWin32HandlePropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00645)"}, + {VALIDATION_ERROR_0c60050c, "The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR, or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR, allocationSize must match the size reported in the memory requirements of the image or buffer member of the instance of VkDedicatedAllocationMemoryAllocateInfoNV included in the pNext chain.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00646)"}, + {VALIDATION_ERROR_0c60050e, "The spec valid usage text states 'If the parameters define an import operation and the external handle type is VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, allocationSize must match the size specified when creating the Direct3D 12 heap from which the external handle was extracted.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-allocationSize-00647)"}, + {VALIDATION_ERROR_0c600510, "The spec valid usage text states 'If the parameters define an import operation and the external handle is a POSIX file descriptor created outside of the Vulkan API, the value of memoryTypeIndex must be one of those returned by vkGetMemoryFdPropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryAllocateInfo-memoryTypeIndex-00648)"}, + {VALIDATION_ERROR_0c61c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDedicatedAllocationMemoryAllocateInfoNV, VkMemoryAllocateFlagsInfoKHX, VkMemoryDedicatedAllocateInfoKHR, VkExportMemoryAllocateInfoKHR, VkImportMemoryWin32HandleInfoKHR, VkImportMemoryWin32HandleInfoNV, VkImportMemoryFdInfoKHR, VkExportMemoryAllocateInfoNV, VkExportMemoryWin32HandleInfoKHR, or VkExportMemoryWin32HandleInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-pNext-pNext)"}, {VALIDATION_ERROR_0c62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-sType-sType)"}, {VALIDATION_ERROR_0c62b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryAllocateInfo-sType-unique)"}, {VALIDATION_ERROR_0c806801, "The spec valid usage text states 'dstAccessMask must be a valid combination of VkAccessFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryBarrier-dstAccessMask-parameter)"}, @@ -4127,24 +4273,24 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0d830401, "The spec valid usage text states 'type must be a valid VkObjectEntryTypeNVX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkObjectTableVertexBufferEntryNVX-type-parameter)"}, {VALIDATION_ERROR_0da1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-pNext-pNext)"}, {VALIDATION_ERROR_0da2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceDiscardRectanglePropertiesEXT-sType-sType)"}, - {VALIDATION_ERROR_0dc09001, "The spec valid usage text states 'flags must be a valid combination of VkBufferCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHX-flags-parameter)"}, - {VALIDATION_ERROR_0dc09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHX-handleType-parameter)"}, - {VALIDATION_ERROR_0dc1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_0dc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHX-sType-sType)"}, - {VALIDATION_ERROR_0dc30601, "The spec valid usage text states 'usage must be a valid combination of VkBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHX-usage-parameter)"}, - {VALIDATION_ERROR_0dc30603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHX-usage-requiredbitmask)"}, - {VALIDATION_ERROR_0de09c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalImageFormatInfoKHX-handleType-parameter)"}, - {VALIDATION_ERROR_0de2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalImageFormatInfoKHX-sType-sType)"}, - {VALIDATION_ERROR_0e009c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfoKHX-handleType-parameter)"}, - {VALIDATION_ERROR_0e01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfoKHX-pNext-pNext)"}, - {VALIDATION_ERROR_0e02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfoKHX-sType-sType)"}, + {VALIDATION_ERROR_0dc09001, "The spec valid usage text states 'flags must be a valid combination of VkBufferCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHR-flags-parameter)"}, + {VALIDATION_ERROR_0dc09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_0dc1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_0dc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_0dc30601, "The spec valid usage text states 'usage must be a valid combination of VkBufferUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHR-usage-parameter)"}, + {VALIDATION_ERROR_0dc30603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalBufferInfoKHR-usage-requiredbitmask)"}, + {VALIDATION_ERROR_0de09c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalImageFormatInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_0de2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalImageFormatInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_0e009c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_0e01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_0e02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfoKHR-sType-sType)"}, {VALIDATION_ERROR_0e200486, "The spec valid usage text states 'If any member of this structure is VK_FALSE, as returned by vkGetPhysicalDeviceFeatures, then it must be VK_FALSE when passed as part of the VkDeviceCreateInfo struct when creating a device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceFeatures-None-00579)"}, - {VALIDATION_ERROR_0e41c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceMultiviewFeaturesKHX or VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceFeatures2KHR-pNext-pNext)"}, + {VALIDATION_ERROR_0e41c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDevice16BitStorageFeaturesKHR, VkPhysicalDeviceVariablePointerFeaturesKHR, VkPhysicalDeviceMultiviewFeaturesKHX, or VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceFeatures2KHR-pNext-pNext)"}, {VALIDATION_ERROR_0e42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceFeatures2KHR-sType-sType)"}, {VALIDATION_ERROR_0e42b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceFeatures2KHR-sType-unique)"}, {VALIDATION_ERROR_0e609001, "The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2KHR-flags-parameter)"}, {VALIDATION_ERROR_0e609201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2KHR-format-parameter)"}, - {VALIDATION_ERROR_0e61c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceExternalImageFormatInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2KHR-pNext-pNext)"}, + {VALIDATION_ERROR_0e61c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceExternalImageFormatInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2KHR-pNext-pNext)"}, {VALIDATION_ERROR_0e62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2KHR-sType-sType)"}, {VALIDATION_ERROR_0e62fa01, "The spec valid usage text states 'tiling must be a valid VkImageTiling value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2KHR-tiling-parameter)"}, {VALIDATION_ERROR_0e630401, "The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceImageFormatInfo2KHR-type-parameter)"}, @@ -4208,6 +4354,7 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_0f809005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-flags-zerobitmask)"}, {VALIDATION_ERROR_0f81c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-pNext-pNext)"}, {VALIDATION_ERROR_0f82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDiscardRectangleStateCreateInfoEXT-sType-sType)"}, + {VALIDATION_ERROR_0fa00b44, "The spec valid usage text states 'Each element of pDynamicStates must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-01442)"}, {VALIDATION_ERROR_0fa07c1b, "The spec valid usage text states 'dynamicStateCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-dynamicStateCount-arraylength)"}, {VALIDATION_ERROR_0fa09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-flags-zerobitmask)"}, {VALIDATION_ERROR_0fa15801, "The spec valid usage text states 'pDynamicStates must be a pointer to an array of dynamicStateCount valid VkDynamicState values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter)"}, @@ -4298,8 +4445,9 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_10c00986, "The spec valid usage text states 'scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219)"}, {VALIDATION_ERROR_10c00988, "The spec valid usage text states 'scissorCount and viewportCount must be identical' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220)"}, {VALIDATION_ERROR_10c09005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_10c1c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkPipelineViewportWScalingStateCreateInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_10c1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineViewportWScalingStateCreateInfoNV or VkPipelineViewportSwizzleStateCreateInfoNV' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_10c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-sType-sType)"}, + {VALIDATION_ERROR_10c2b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-sType-unique)"}, {VALIDATION_ERROR_10c2b61b, "The spec valid usage text states 'scissorCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength)"}, {VALIDATION_ERROR_10c30a1b, "The spec valid usage text states 'viewportCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength)"}, {VALIDATION_ERROR_10e0097e, "The spec valid usage text states 'viewportCount must match the viewportCount set in VkPipelineViewportStateCreateInfo' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215)"}, @@ -4364,7 +4512,7 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_12209005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-flags-zerobitmask)"}, {VALIDATION_ERROR_1220f201, "The spec valid usage text states 'If attachmentCount is not 0, pAttachments must be a pointer to an array of attachmentCount valid VkAttachmentDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-parameter)"}, {VALIDATION_ERROR_12212601, "The spec valid usage text states 'If dependencyCount is not 0, pDependencies must be a pointer to an array of dependencyCount valid VkSubpassDependency structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-parameter)"}, - {VALIDATION_ERROR_1221c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_1221c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkRenderPassMultiviewCreateInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_12224201, "The spec valid usage text states 'pSubpasses must be a pointer to an array of subpassCount valid VkSubpassDescription structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-pSubpasses-parameter)"}, {VALIDATION_ERROR_1222b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-sType-sType)"}, {VALIDATION_ERROR_1222e61b, "The spec valid usage text states 'subpassCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkRenderPassCreateInfo-subpassCount-arraylength)"}, @@ -4402,8 +4550,9 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_1261c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkSamplerReductionModeCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_1262b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerCreateInfo-sType-sType)"}, {VALIDATION_ERROR_12809005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-flags-zerobitmask)"}, - {VALIDATION_ERROR_1281c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-pNext-pNext)"}, + {VALIDATION_ERROR_1281c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExportSemaphoreCreateInfoKHR or VkExportSemaphoreWin32HandleInfoKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-pNext-pNext)"}, {VALIDATION_ERROR_1282b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-sType-sType)"}, + {VALIDATION_ERROR_1282b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreCreateInfo-sType-unique)"}, {VALIDATION_ERROR_12a0087a, "The spec valid usage text states 'codeSize must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-codeSize-01085)"}, {VALIDATION_ERROR_12a0087c, "The spec valid usage text states 'codeSize must be a multiple of 4' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-codeSize-01086)"}, {VALIDATION_ERROR_12a0087e, "The spec valid usage text states 'pCode must point to valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01087)"}, @@ -4465,7 +4614,7 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_13c0009a, "The spec valid usage text states 'If the tessellation shaders feature is not enabled, any given element of pWaitDstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-00077)"}, {VALIDATION_ERROR_13c0009c, "The spec valid usage text states 'Any given element of pWaitDstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-00078)"}, {VALIDATION_ERROR_13c11401, "The spec valid usage text states 'If commandBufferCount is not 0, pCommandBuffers must be a pointer to an array of commandBufferCount valid VkCommandBuffer handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pCommandBuffers-parameter)"}, - {VALIDATION_ERROR_13c1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkWin32KeyedMutexAcquireReleaseInfoNV, VkWin32KeyedMutexAcquireReleaseInfoKHX, VkD3D12FenceSubmitInfoKHX, or VkDeviceGroupSubmitInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pNext-pNext)"}, + {VALIDATION_ERROR_13c1c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkWin32KeyedMutexAcquireReleaseInfoNV, VkWin32KeyedMutexAcquireReleaseInfoKHR, VkD3D12FenceSubmitInfoKHR, or VkDeviceGroupSubmitInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pNext-pNext)"}, {VALIDATION_ERROR_13c23401, "The spec valid usage text states 'If signalSemaphoreCount is not 0, pSignalSemaphores must be a pointer to an array of signalSemaphoreCount valid VkSemaphore handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pSignalSemaphores-parameter)"}, {VALIDATION_ERROR_13c27001, "The spec valid usage text states 'If waitSemaphoreCount is not 0, pWaitDstStageMask must be a pointer to an array of waitSemaphoreCount valid combinations of VkPipelineStageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-parameter)"}, {VALIDATION_ERROR_13c27003, "The spec valid usage text states 'Each element of pWaitDstStageMask must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSubmitInfo-pWaitDstStageMask-requiredbitmask)"}, @@ -4550,10 +4699,11 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_1460ae03, "The spec valid usage text states 'imageUsage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask)"}, {VALIDATION_ERROR_1460de01, "The spec valid usage text states 'If oldSwapchain is not VK_NULL_HANDLE, oldSwapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter)"}, {VALIDATION_ERROR_1460de07, "The spec valid usage text states 'If oldSwapchain is a valid handle, it must have been created, allocated, or retrieved from surface' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent)"}, - {VALIDATION_ERROR_1461c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkDeviceGroupSwapchainCreateInfoKHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_1461c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupSwapchainCreateInfoKHX or VkSwapchainCounterCreateInfoEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-pNext-pNext)"}, {VALIDATION_ERROR_14629401, "The spec valid usage text states 'preTransform must be a valid VkSurfaceTransformFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-preTransform-parameter)"}, {VALIDATION_ERROR_14629601, "The spec valid usage text states 'presentMode must be a valid VkPresentModeKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-presentMode-parameter)"}, {VALIDATION_ERROR_1462b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_1462b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-sType-unique)"}, {VALIDATION_ERROR_1462ec01, "The spec valid usage text states 'surface must be a valid VkSurfaceKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSwapchainCreateInfoKHR-surface-parameter)"}, {VALIDATION_ERROR_14805a1b, "The spec valid usage text states 'disabledValidationCheckCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkValidationFlagsEXT-disabledValidationCheckCount-arraylength)"}, {VALIDATION_ERROR_14814401, "The spec valid usage text states 'pDisabledValidationChecks must be a pointer to an array of disabledValidationCheckCount VkValidationCheckEXT values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkValidationFlagsEXT-pDisabledValidationChecks-parameter)"}, @@ -4590,14 +4740,14 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_15409005, "The spec valid usage text states 'flags must be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-flags-zerobitmask)"}, {VALIDATION_ERROR_1541c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-pNext-pNext)"}, {VALIDATION_ERROR_1542b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWaylandSurfaceCreateInfoKHR-sType-sType)"}, - {VALIDATION_ERROR_15600009, "The spec valid usage text states 'Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHX-commonparent)"}, - {VALIDATION_ERROR_156000a2, "The spec valid usage text states 'Each member of pAcquireSyncs and pReleaseSyncs must be a device memory object imported by setting VkImportMemoryWin32HandleInfoKHX::handleType to VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHX-pAcquireSyncs-00081)"}, - {VALIDATION_ERROR_1560e201, "The spec valid usage text states 'If acquireCount is not 0, pAcquireKeys must be a pointer to an array of acquireCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHX-pAcquireKeys-parameter)"}, - {VALIDATION_ERROR_1560e401, "The spec valid usage text states 'If acquireCount is not 0, pAcquireSyncs must be a pointer to an array of acquireCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHX-pAcquireSyncs-parameter)"}, - {VALIDATION_ERROR_1560e801, "The spec valid usage text states 'If acquireCount is not 0, pAcquireTimeouts must be a pointer to an array of acquireCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHX-pAcquireTimeouts-parameter)"}, - {VALIDATION_ERROR_15621201, "The spec valid usage text states 'If releaseCount is not 0, pReleaseKeys must be a pointer to an array of releaseCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHX-pReleaseKeys-parameter)"}, - {VALIDATION_ERROR_15621401, "The spec valid usage text states 'If releaseCount is not 0, pReleaseSyncs must be a pointer to an array of releaseCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHX-pReleaseSyncs-parameter)"}, - {VALIDATION_ERROR_1562b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHX-sType-sType)"}, + {VALIDATION_ERROR_15600009, "The spec valid usage text states 'Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-commonparent)"}, + {VALIDATION_ERROR_156000a2, "The spec valid usage text states 'Each member of pAcquireSyncs and pReleaseSyncs must be a device memory object imported by setting VkImportMemoryWin32HandleInfoKHR::handleType to VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR or VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-00081)"}, + {VALIDATION_ERROR_1560e201, "The spec valid usage text states 'If acquireCount is not 0, pAcquireKeys must be a pointer to an array of acquireCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireKeys-parameter)"}, + {VALIDATION_ERROR_1560e401, "The spec valid usage text states 'If acquireCount is not 0, pAcquireSyncs must be a pointer to an array of acquireCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireSyncs-parameter)"}, + {VALIDATION_ERROR_1560e801, "The spec valid usage text states 'If acquireCount is not 0, pAcquireTimeouts must be a pointer to an array of acquireCount uint32_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pAcquireTimeouts-parameter)"}, + {VALIDATION_ERROR_15621201, "The spec valid usage text states 'If releaseCount is not 0, pReleaseKeys must be a pointer to an array of releaseCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseKeys-parameter)"}, + {VALIDATION_ERROR_15621401, "The spec valid usage text states 'If releaseCount is not 0, pReleaseSyncs must be a pointer to an array of releaseCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-pReleaseSyncs-parameter)"}, + {VALIDATION_ERROR_1562b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoKHR-sType-sType)"}, {VALIDATION_ERROR_15800009, "The spec valid usage text states 'Both of the elements of pAcquireSyncs, and the elements of pReleaseSyncs that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-commonparent)"}, {VALIDATION_ERROR_1580e201, "The spec valid usage text states 'If acquireCount is not 0, pAcquireKeys must be a pointer to an array of acquireCount uint64_t values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireKeys-parameter)"}, {VALIDATION_ERROR_1580e401, "The spec valid usage text states 'If acquireCount is not 0, pAcquireSyncs must be a pointer to an array of acquireCount valid VkDeviceMemory handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkWin32KeyedMutexAcquireReleaseInfoNV-pAcquireSyncs-parameter)"}, @@ -4694,8 +4844,9 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_17000816, "The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memory-01035)"}, {VALIDATION_ERROR_17000818, "The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-memoryOffset-01036)"}, {VALIDATION_ERROR_1700081a, "The spec valid usage text states 'The size member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-size-01037)"}, - {VALIDATION_ERROR_1700081c, "The spec valid usage text states 'If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to buffer and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01038)"}, - {VALIDATION_ERROR_1700081e, "The spec valid usage text states 'If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01039)"}, + {VALIDATION_ERROR_1700081c, "The spec valid usage text states 'If buffer was created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::buffer equal to a buffer handle created with identical creation parameters to buffer and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01038)"}, + {VALIDATION_ERROR_1700081e, "The spec valid usage text states 'If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01039)"}, + {VALIDATION_ERROR_17000b48, "The spec valid usage text states 'If buffer requires a dedicated allocation(as reported by vkGetBufferMemoryRequirements2KHR in VkMemoryDedicatedRequirementsKHR::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfoKHR::buffer equal to buffer and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindBufferMemory-buffer-01444)"}, {VALIDATION_ERROR_17001a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-parameter)"}, {VALIDATION_ERROR_17001a07, "The spec valid usage text states 'buffer must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-buffer-parent)"}, {VALIDATION_ERROR_17005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindBufferMemory-device-parameter)"}, @@ -4710,8 +4861,9 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_1740082e, "The spec valid usage text states 'memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memory-01047)"}, {VALIDATION_ERROR_17400830, "The spec valid usage text states 'memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-memoryOffset-01048)"}, {VALIDATION_ERROR_17400832, "The spec valid usage text states 'The size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image must be less than or equal to the size of memory minus memoryOffset' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-size-01049)"}, - {VALIDATION_ERROR_17400834, "The spec valid usage text states 'If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to image and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01050)"}, - {VALIDATION_ERROR_17400836, "The spec valid usage text states 'If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01051)"}, + {VALIDATION_ERROR_17400834, "The spec valid usage text states 'If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to an image handle created with identical creation parameters to image and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01050)"}, + {VALIDATION_ERROR_17400836, "The spec valid usage text states 'If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-01051)"}, + {VALIDATION_ERROR_17400b4a, "The spec valid usage text states 'If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2KHR in VkMemoryDedicatedRequirementsKHR::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfoKHR::image equal to image and memoryOffset must be zero' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-01445)"}, {VALIDATION_ERROR_17405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-device-parameter)"}, {VALIDATION_ERROR_1740a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-parameter)"}, {VALIDATION_ERROR_1740a007, "The spec valid usage text states 'image must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkBindImageMemory-image-parent)"}, @@ -6029,26 +6181,28 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_2a624401, "The spec valid usage text states 'pSubresource must be a pointer to a valid VkImageSubresource structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageSubresourceLayout-pSubresource-parameter)"}, {VALIDATION_ERROR_2a80bc01, "The spec valid usage text states 'If instance is not NULL, instance must be a valid VkInstance handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetInstanceProcAddr-instance-parameter)"}, {VALIDATION_ERROR_2a81c001, "The spec valid usage text states 'pName must be a null-terminated UTF-8 string' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetInstanceProcAddr-pName-parameter)"}, - {VALIDATION_ERROR_2aa0053e, "The spec valid usage text states 'handleType must have been included in VkExportMemoryAllocateInfoKHX::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHX-handleType-00671)"}, - {VALIDATION_ERROR_2aa00540, "The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHX-handleType-00672)"}, - {VALIDATION_ERROR_2aa05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHX-device-parameter)"}, - {VALIDATION_ERROR_2aa09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHX-handleType-parameter)"}, - {VALIDATION_ERROR_2aa0c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHX-memory-parameter)"}, - {VALIDATION_ERROR_2aa0c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHX-memory-parent)"}, - {VALIDATION_ERROR_2aa16c01, "The spec valid usage text states 'pFd must be a pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHX-pFd-parameter)"}, - {VALIDATION_ERROR_2ac00542, "The spec valid usage text states 'fd must be an external memory handle created outside of the Vulkan API.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHX-fd-00673)"}, - {VALIDATION_ERROR_2ac00544, "The spec valid usage text states 'handleType must not be one of the handle types defined as opaque.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHX-handleType-00674)"}, - {VALIDATION_ERROR_2ac05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHX-device-parameter)"}, - {VALIDATION_ERROR_2ac09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHX-handleType-parameter)"}, - {VALIDATION_ERROR_2ac1ae01, "The spec valid usage text states 'pMemoryFdProperties must be a pointer to a VkMemoryFdPropertiesKHX structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHX-pMemoryFdProperties-parameter)"}, - {VALIDATION_ERROR_2ae0052c, "The spec valid usage text states 'handleType must have been included in VkExportMemoryAllocateInfoKHX::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHX-handleType-00662)"}, - {VALIDATION_ERROR_2ae0052e, "The spec valid usage text states 'If handleType is defined as an NT handle, vkGetMemoryWin32HandleKHX must be called no more than once for each valid unique combination of memory and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHX-handleType-00663)"}, - {VALIDATION_ERROR_2ae00530, "The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHX-handleType-00664)"}, - {VALIDATION_ERROR_2ae05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHX-device-parameter)"}, - {VALIDATION_ERROR_2ae09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHX-handleType-parameter)"}, - {VALIDATION_ERROR_2ae0c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHX-memory-parameter)"}, - {VALIDATION_ERROR_2ae0c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHX-memory-parent)"}, - {VALIDATION_ERROR_2ae17c01, "The spec valid usage text states 'pHandle must be a pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHX-pHandle-parameter)"}, + {VALIDATION_ERROR_2aa0053e, "The spec valid usage text states 'handleType must have been included in VkExportMemoryAllocateInfoKHR::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHR-handleType-00671)"}, + {VALIDATION_ERROR_2aa00540, "The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHR-handleType-00672)"}, + {VALIDATION_ERROR_2aa05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHR-device-parameter)"}, + {VALIDATION_ERROR_2aa09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHR-handleType-parameter)"}, + {VALIDATION_ERROR_2aa0c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHR-memory-parameter)"}, + {VALIDATION_ERROR_2aa0c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHR-memory-parent)"}, + {VALIDATION_ERROR_2aa16c01, "The spec valid usage text states 'pFd must be a pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHR-pFd-parameter)"}, + {VALIDATION_ERROR_2aa39e01, "The spec valid usage text states 'pGetFdInfo must be a pointer to a valid VkMemoryGetFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdKHR-pGetFdInfo-parameter)"}, + {VALIDATION_ERROR_2ac00542, "The spec valid usage text states 'fd must be an external memory handle created outside of the Vulkan API.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-fd-00673)"}, + {VALIDATION_ERROR_2ac00544, "The spec valid usage text states 'handleType must not be one of the handle types defined as opaque.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-handleType-00674)"}, + {VALIDATION_ERROR_2ac05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-device-parameter)"}, + {VALIDATION_ERROR_2ac09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter)"}, + {VALIDATION_ERROR_2ac1ae01, "The spec valid usage text states 'pMemoryFdProperties must be a pointer to a VkMemoryFdPropertiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter)"}, + {VALIDATION_ERROR_2ae0052c, "The spec valid usage text states 'handleType must have been included in VkExportMemoryAllocateInfoKHR::handleTypes when memory was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-handleType-00662)"}, + {VALIDATION_ERROR_2ae0052e, "The spec valid usage text states 'If handleType is defined as an NT handle, vkGetMemoryWin32HandleKHR must be called no more than once for each valid unique combination of memory and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-handleType-00663)"}, + {VALIDATION_ERROR_2ae00530, "The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-handleType-00664)"}, + {VALIDATION_ERROR_2ae05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-device-parameter)"}, + {VALIDATION_ERROR_2ae09c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-handleType-parameter)"}, + {VALIDATION_ERROR_2ae0c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-memory-parameter)"}, + {VALIDATION_ERROR_2ae0c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-memory-parent)"}, + {VALIDATION_ERROR_2ae17c01, "The spec valid usage text states 'pHandle must be a pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-pHandle-parameter)"}, + {VALIDATION_ERROR_2ae3a001, "The spec valid usage text states 'pGetWin32HandleInfo must be a pointer to a valid VkMemoryGetWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleKHR-pGetWin32HandleInfo-parameter)"}, {VALIDATION_ERROR_2b000a5c, "The spec valid usage text states 'handleType must be a flag specified in VkExportMemoryAllocateInfoNV::handleTypes when allocating memory' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-handleType-01326)"}, {VALIDATION_ERROR_2b005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-device-parameter)"}, {VALIDATION_ERROR_2b009c01, "The spec valid usage text states 'handleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-handleType-parameter)"}, @@ -6056,11 +6210,11 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_2b00c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-memory-parameter)"}, {VALIDATION_ERROR_2b00c607, "The spec valid usage text states 'memory must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-memory-parent)"}, {VALIDATION_ERROR_2b017c01, "The spec valid usage text states 'pHandle must be a pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandleNV-pHandle-parameter)"}, - {VALIDATION_ERROR_2b200532, "The spec valid usage text states 'handle must be an external memory handle created outside of the Vulkan API.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHX-handle-00665)"}, - {VALIDATION_ERROR_2b200534, "The spec valid usage text states 'handleType must not be one of the handle types defined as opaque.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHX-handleType-00666)"}, - {VALIDATION_ERROR_2b205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHX-device-parameter)"}, - {VALIDATION_ERROR_2b209c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHX-handleType-parameter)"}, - {VALIDATION_ERROR_2b21b601, "The spec valid usage text states 'pMemoryWin32HandleProperties must be a pointer to a VkMemoryWin32HandlePropertiesKHX structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHX-pMemoryWin32HandleProperties-parameter)"}, + {VALIDATION_ERROR_2b200532, "The spec valid usage text states 'handle must be an external memory handle created outside of the Vulkan API.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-handle-00665)"}, + {VALIDATION_ERROR_2b200534, "The spec valid usage text states 'handleType must not be one of the handle types defined as opaque.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-00666)"}, + {VALIDATION_ERROR_2b205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter)"}, + {VALIDATION_ERROR_2b209c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter)"}, + {VALIDATION_ERROR_2b21b601, "The spec valid usage text states 'pMemoryWin32HandleProperties must be a pointer to a VkMemoryWin32HandlePropertiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetMemoryWin32HandlePropertiesKHR-pMemoryWin32HandleProperties-parameter)"}, {VALIDATION_ERROR_2b405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-device-parameter)"}, {VALIDATION_ERROR_2b41ec01, "The spec valid usage text states 'pPresentationTimingCount must be a pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimingCount-parameter)"}, {VALIDATION_ERROR_2b41ee01, "The spec valid usage text states 'If the value referenced by pPresentationTimingCount is not 0, and pPresentationTimings is not NULL, pPresentationTimings must be a pointer to an array of pPresentationTimingCount VkPastPresentationTimingGOOGLE structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPastPresentationTimingGOOGLE-pPresentationTimings-parameter)"}, @@ -6071,9 +6225,9 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_2b81f401, "The spec valid usage text states 'If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkDisplayPropertiesKHR structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pProperties-parameter)"}, {VALIDATION_ERROR_2b81f601, "The spec valid usage text states 'pPropertyCount must be a pointer to a uint32_t value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-pPropertyCount-parameter)"}, {VALIDATION_ERROR_2b827a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter)"}, - {VALIDATION_ERROR_2ba16201, "The spec valid usage text states 'pExternalBufferInfo must be a pointer to a valid VkPhysicalDeviceExternalBufferInfoKHX structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferPropertiesKHX-pExternalBufferInfo-parameter)"}, - {VALIDATION_ERROR_2ba16401, "The spec valid usage text states 'pExternalBufferProperties must be a pointer to a VkExternalBufferPropertiesKHX structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferPropertiesKHX-pExternalBufferProperties-parameter)"}, - {VALIDATION_ERROR_2ba27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferPropertiesKHX-physicalDevice-parameter)"}, + {VALIDATION_ERROR_2ba16201, "The spec valid usage text states 'pExternalBufferInfo must be a pointer to a valid VkPhysicalDeviceExternalBufferInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferPropertiesKHR-pExternalBufferInfo-parameter)"}, + {VALIDATION_ERROR_2ba16401, "The spec valid usage text states 'pExternalBufferProperties must be a pointer to a VkExternalBufferPropertiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferPropertiesKHR-pExternalBufferProperties-parameter)"}, + {VALIDATION_ERROR_2ba27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalBufferPropertiesKHR-physicalDevice-parameter)"}, {VALIDATION_ERROR_2bc08201, "The spec valid usage text states 'externalHandleType must be a valid combination of VkExternalMemoryHandleTypeFlagBitsNV values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter)"}, {VALIDATION_ERROR_2bc09001, "The spec valid usage text states 'flags must be a valid combination of VkImageCreateFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter)"}, {VALIDATION_ERROR_2bc09201, "The spec valid usage text states 'format must be a valid VkFormat value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-format-parameter)"}, @@ -6083,9 +6237,9 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_2bc30401, "The spec valid usage text states 'type must be a valid VkImageType value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-type-parameter)"}, {VALIDATION_ERROR_2bc30601, "The spec valid usage text states 'usage must be a valid combination of VkImageUsageFlagBits values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-parameter)"}, {VALIDATION_ERROR_2bc30603, "The spec valid usage text states 'usage must not be 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask)"}, - {VALIDATION_ERROR_2be16801, "The spec valid usage text states 'pExternalSemaphoreInfo must be a pointer to a valid VkPhysicalDeviceExternalSemaphoreInfoKHX structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphorePropertiesKHX-pExternalSemaphoreInfo-parameter)"}, - {VALIDATION_ERROR_2be16a01, "The spec valid usage text states 'pExternalSemaphoreProperties must be a pointer to a VkExternalSemaphorePropertiesKHX structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphorePropertiesKHX-pExternalSemaphoreProperties-parameter)"}, - {VALIDATION_ERROR_2be27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphorePropertiesKHX-physicalDevice-parameter)"}, + {VALIDATION_ERROR_2be16801, "The spec valid usage text states 'pExternalSemaphoreInfo must be a pointer to a valid VkPhysicalDeviceExternalSemaphoreInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphorePropertiesKHR-pExternalSemaphoreInfo-parameter)"}, + {VALIDATION_ERROR_2be16a01, "The spec valid usage text states 'pExternalSemaphoreProperties must be a pointer to a VkExternalSemaphorePropertiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphorePropertiesKHR-pExternalSemaphoreProperties-parameter)"}, + {VALIDATION_ERROR_2be27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalSemaphorePropertiesKHR-physicalDevice-parameter)"}, {VALIDATION_ERROR_2c016e01, "The spec valid usage text states 'pFeatures must be a pointer to a VkPhysicalDeviceFeatures structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures-pFeatures-parameter)"}, {VALIDATION_ERROR_2c027a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter)"}, {VALIDATION_ERROR_2c216e01, "The spec valid usage text states 'pFeatures must be a pointer to a VkPhysicalDeviceFeatures2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceFeatures2KHR-pFeatures-parameter)"}, @@ -6208,27 +6362,29 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_30017a01, "The spec valid usage text states 'pGranularity must be a pointer to a VkExtent2D structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-pGranularity-parameter)"}, {VALIDATION_ERROR_3002ae01, "The spec valid usage text states 'renderPass must be a valid VkRenderPass handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-renderPass-parameter)"}, {VALIDATION_ERROR_3002ae07, "The spec valid usage text states 'renderPass must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetRenderAreaGranularity-renderPass-parent)"}, - {VALIDATION_ERROR_302008d8, "The spec valid usage text states 'handleType must have been included in VkExportSemaphoreCreateInfoKHX::handleTypes when semaphore's current state was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-handleType-01132)"}, - {VALIDATION_ERROR_302008da, "The spec valid usage text states 'semaphore must not currently have its state replaced by imported semaphore state as described below in Importing Semaphore State unless that imported semaphore state's handle type was included in VkExternalSemaphorePropertiesKHX::exportFromImportedHandleTypes.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-semaphore-01133)"}, - {VALIDATION_ERROR_302008dc, "The spec valid usage text states 'If handleType refers to a handle type with temporary import semantics, as defined below in Importing Semaphore State, there must be no queue waiting on semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-handleType-01134)"}, - {VALIDATION_ERROR_302008de, "The spec valid usage text states 'If handleType refers to a handle type with temporary import semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-handleType-01135)"}, - {VALIDATION_ERROR_302008e0, "The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-handleType-01136)"}, - {VALIDATION_ERROR_30205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-device-parameter)"}, - {VALIDATION_ERROR_30209c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-handleType-parameter)"}, - {VALIDATION_ERROR_30216c01, "The spec valid usage text states 'pFd must be a pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-pFd-parameter)"}, - {VALIDATION_ERROR_3022b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-semaphore-parameter)"}, - {VALIDATION_ERROR_3022b807, "The spec valid usage text states 'semaphore must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHX-semaphore-parent)"}, - {VALIDATION_ERROR_304008cc, "The spec valid usage text states 'handleType must have been included in VkExportSemaphoreCreateInfoKHX::handleTypes when semaphore's current state was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-handleType-01126)"}, - {VALIDATION_ERROR_304008ce, "The spec valid usage text states 'If handleType is defined as an NT handle, vkGetSemaphoreWin32HandleKHX must be called no more than once for each valid unique combination of semaphore and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-handleType-01127)"}, - {VALIDATION_ERROR_304008d0, "The spec valid usage text states 'semaphore must not currently have its state replaced by imported semaphore state as described below in Importing Semaphore State unless that imported semaphore state's handle type was included in VkExternalSemaphorePropertiesKHX::exportFromImportedHandleTypes.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-semaphore-01128)"}, - {VALIDATION_ERROR_304008d2, "The spec valid usage text states 'If handleType refers to a handle type with temporary import semantics, as defined below in Importing Semaphore State, there must be no queue waiting on semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-handleType-01129)"}, - {VALIDATION_ERROR_304008d4, "The spec valid usage text states 'If handleType refers to a handle type with temporary import semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-handleType-01130)"}, - {VALIDATION_ERROR_304008d6, "The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-handleType-01131)"}, - {VALIDATION_ERROR_30405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-device-parameter)"}, - {VALIDATION_ERROR_30409c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHX value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-handleType-parameter)"}, - {VALIDATION_ERROR_30417c01, "The spec valid usage text states 'pHandle must be a pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-pHandle-parameter)"}, - {VALIDATION_ERROR_3042b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-semaphore-parameter)"}, - {VALIDATION_ERROR_3042b807, "The spec valid usage text states 'semaphore must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHX-semaphore-parent)"}, + {VALIDATION_ERROR_302008d8, "The spec valid usage text states 'handleType must have been included in VkExportSemaphoreCreateInfoKHR::handleTypes when semaphore's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-handleType-01132)"}, + {VALIDATION_ERROR_302008da, "The spec valid usage text states 'semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload's handle type was included in VkExternalSemaphorePropertiesKHR::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-semaphore-01133)"}, + {VALIDATION_ERROR_302008dc, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-handleType-01134)"}, + {VALIDATION_ERROR_302008de, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-handleType-01135)"}, + {VALIDATION_ERROR_302008e0, "The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-handleType-01136)"}, + {VALIDATION_ERROR_30205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-device-parameter)"}, + {VALIDATION_ERROR_30209c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-handleType-parameter)"}, + {VALIDATION_ERROR_30216c01, "The spec valid usage text states 'pFd must be a pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-pFd-parameter)"}, + {VALIDATION_ERROR_3022b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-semaphore-parameter)"}, + {VALIDATION_ERROR_3022b807, "The spec valid usage text states 'semaphore must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-semaphore-parent)"}, + {VALIDATION_ERROR_30239e01, "The spec valid usage text states 'pGetFdInfo must be a pointer to a valid VkSemaphoreGetFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreFdKHR-pGetFdInfo-parameter)"}, + {VALIDATION_ERROR_304008cc, "The spec valid usage text states 'handleType must have been included in VkExportSemaphoreCreateInfoKHR::handleTypes when the semaphore's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-handleType-01126)"}, + {VALIDATION_ERROR_304008ce, "The spec valid usage text states 'If handleType is defined as an NT handle, vkGetSemaphoreWin32HandleKHR must be called no more than once for each valid unique combination of semaphore and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-handleType-01127)"}, + {VALIDATION_ERROR_304008d0, "The spec valid usage text states 'semaphore must not currently have its payload replaced by an imported payload as described below in Importing Semaphore Payloads unless that imported payload's handle type was included in VkExternalSemaphorePropertiesKHR::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-semaphore-01128)"}, + {VALIDATION_ERROR_304008d2, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, as defined below in Importing Semaphore Payloads, there must be no queue waiting on semaphore.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-handleType-01129)"}, + {VALIDATION_ERROR_304008d4, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, semaphore must be signaled, or have an associated semaphore signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-handleType-01130)"}, + {VALIDATION_ERROR_304008d6, "The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-handleType-01131)"}, + {VALIDATION_ERROR_30405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-device-parameter)"}, + {VALIDATION_ERROR_30409c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-handleType-parameter)"}, + {VALIDATION_ERROR_30417c01, "The spec valid usage text states 'pHandle must be a pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-pHandle-parameter)"}, + {VALIDATION_ERROR_3042b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-semaphore-parameter)"}, + {VALIDATION_ERROR_3042b807, "The spec valid usage text states 'semaphore must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-semaphore-parent)"}, + {VALIDATION_ERROR_3043a001, "The spec valid usage text states 'pGetWin32HandleInfo must be a pointer to a valid VkSemaphoreGetWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSemaphoreWin32HandleKHR-pGetWin32HandleInfo-parameter)"}, {VALIDATION_ERROR_306009ba, "The spec valid usage text states 'One or more present commands on swapchain must have been processed by the presentation engine.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-swapchain-01245)"}, {VALIDATION_ERROR_30603601, "The spec valid usage text states 'counter must be a valid VkSurfaceCounterFlagBitsEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-counter-parameter)"}, {VALIDATION_ERROR_30605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSwapchainCounterEXT-device-parameter)"}, @@ -6240,11 +6396,11 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_3082f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSwapchainImagesKHR-swapchain-parameter)"}, {VALIDATION_ERROR_30a05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSwapchainStatusKHR-device-parameter)"}, {VALIDATION_ERROR_30a2f001, "The spec valid usage text states 'swapchain must be a valid VkSwapchainKHR handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetSwapchainStatusKHR-swapchain-parameter)"}, - {VALIDATION_ERROR_30c008ec, "The spec valid usage text states 'semaphore must not be associated with any queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreFdKHX-semaphore-01142)"}, - {VALIDATION_ERROR_30c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreFdKHX-device-parameter)"}, - {VALIDATION_ERROR_30c18e01, "The spec valid usage text states 'pImportSemaphoreFdInfo must be a pointer to a valid VkImportSemaphoreFdInfoKHX structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreFdKHX-pImportSemaphoreFdInfo-parameter)"}, - {VALIDATION_ERROR_30e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreWin32HandleKHX-device-parameter)"}, - {VALIDATION_ERROR_30e19001, "The spec valid usage text states 'pImportSemaphoreWin32HandleInfo must be a pointer to a valid VkImportSemaphoreWin32HandleInfoKHX structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreWin32HandleKHX-pImportSemaphoreWin32HandleInfo-parameter)"}, + {VALIDATION_ERROR_30c008ec, "The spec valid usage text states 'semaphore must not be associated with any queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreFdKHR-semaphore-01142)"}, + {VALIDATION_ERROR_30c05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreFdKHR-device-parameter)"}, + {VALIDATION_ERROR_30c18e01, "The spec valid usage text states 'pImportSemaphoreFdInfo must be a pointer to a valid VkImportSemaphoreFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreFdKHR-pImportSemaphoreFdInfo-parameter)"}, + {VALIDATION_ERROR_30e05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreWin32HandleKHR-device-parameter)"}, + {VALIDATION_ERROR_30e19001, "The spec valid usage text states 'pImportSemaphoreWin32HandleInfo must be a pointer to a valid VkImportSemaphoreWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportSemaphoreWin32HandleKHR-pImportSemaphoreWin32HandleInfo-parameter)"}, {VALIDATION_ERROR_31005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkInvalidateMappedMemoryRanges-device-parameter)"}, {VALIDATION_ERROR_3100c81b, "The spec valid usage text states 'memoryRangeCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkInvalidateMappedMemoryRanges-memoryRangeCount-arraylength)"}, {VALIDATION_ERROR_3101b201, "The spec valid usage text states 'pMemoryRanges must be a pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkInvalidateMappedMemoryRanges-pMemoryRanges-parameter)"}, @@ -6379,12 +6535,12 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_33e08a1b, "The spec valid usage text states 'fenceCount must be greater than 0' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-fenceCount-arraylength)"}, {VALIDATION_ERROR_33e17201, "The spec valid usage text states 'pFences must be a pointer to an array of fenceCount valid VkFence handles' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-pFences-parameter)"}, {VALIDATION_ERROR_33e17207, "The spec valid usage text states 'Each element of pFences must have been created, allocated, or retrieved from device' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkWaitForFences-pFences-parent)"}, - {VALIDATION_ERROR_3401c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceIDPropertiesKHX, VkPhysicalDeviceMultiviewPropertiesKHX, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, or VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceProperties2KHR-pNext-pNext)"}, + {VALIDATION_ERROR_3401c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceIDPropertiesKHR, VkPhysicalDeviceMultiviewPropertiesKHX, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, or VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceProperties2KHR-pNext-pNext)"}, {VALIDATION_ERROR_3402b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceProperties2KHR-sType-sType)"}, {VALIDATION_ERROR_3402b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceProperties2KHR-sType-unique)"}, {VALIDATION_ERROR_3421c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFormatProperties2KHR-pNext-pNext)"}, {VALIDATION_ERROR_3422b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFormatProperties2KHR-sType-sType)"}, - {VALIDATION_ERROR_3441c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExternalImageFormatPropertiesKHX or VkTextureLODGatherFormatPropertiesAMD' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageFormatProperties2KHR-pNext-pNext)"}, + {VALIDATION_ERROR_3441c40d, "The spec valid usage text states 'Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkExternalImageFormatPropertiesKHR or VkTextureLODGatherFormatPropertiesAMD' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageFormatProperties2KHR-pNext-pNext)"}, {VALIDATION_ERROR_3442b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageFormatProperties2KHR-sType-sType)"}, {VALIDATION_ERROR_3442b00f, "The spec valid usage text states 'Each sType member in the pNext chain must be unique' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageFormatProperties2KHR-sType-unique)"}, {VALIDATION_ERROR_3461c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceMemoryProperties2KHR-pNext-pNext)"}, @@ -6393,10 +6549,10 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_3482b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSurfaceCapabilities2KHR-sType-sType)"}, {VALIDATION_ERROR_34a1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceGroupPresentCapabilitiesKHX-pNext-pNext)"}, {VALIDATION_ERROR_34a2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkDeviceGroupPresentCapabilitiesKHX-sType-sType)"}, - {VALIDATION_ERROR_34c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalBufferPropertiesKHX-pNext-pNext)"}, - {VALIDATION_ERROR_34c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalBufferPropertiesKHX-sType-sType)"}, - {VALIDATION_ERROR_3521c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalSemaphorePropertiesKHX-pNext-pNext)"}, - {VALIDATION_ERROR_3522b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalSemaphorePropertiesKHX-sType-sType)"}, + {VALIDATION_ERROR_34c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalBufferPropertiesKHR-pNext-pNext)"}, + {VALIDATION_ERROR_34c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalBufferPropertiesKHR-sType-sType)"}, + {VALIDATION_ERROR_3521c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalSemaphorePropertiesKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3522b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalSemaphorePropertiesKHR-sType-sType)"}, {VALIDATION_ERROR_3541c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueueFamilyProperties2KHR-pNext-pNext)"}, {VALIDATION_ERROR_3542b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkQueueFamilyProperties2KHR-sType-sType)"}, {VALIDATION_ERROR_3561c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSparseImageFormatProperties2KHR-pNext-pNext)"}, @@ -6405,10 +6561,10 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_3582b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSurfaceFormat2KHR-sType-sType)"}, {VALIDATION_ERROR_35c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewPropertiesKHX-pNext-pNext)"}, {VALIDATION_ERROR_35c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewPropertiesKHX-sType-sType)"}, - {VALIDATION_ERROR_3601c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalImageFormatPropertiesKHX-pNext-pNext)"}, - {VALIDATION_ERROR_3602b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalImageFormatPropertiesKHX-sType-sType)"}, - {VALIDATION_ERROR_3621c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceIDPropertiesKHX-pNext-pNext)"}, - {VALIDATION_ERROR_3622b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceIDPropertiesKHX-sType-sType)"}, + {VALIDATION_ERROR_3601c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalImageFormatPropertiesKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3602b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalImageFormatPropertiesKHR-sType-sType)"}, + {VALIDATION_ERROR_3621c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceIDPropertiesKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3622b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceIDPropertiesKHR-sType-sType)"}, {VALIDATION_ERROR_3641c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-pNext-pNext)"}, {VALIDATION_ERROR_3642b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType)"}, {VALIDATION_ERROR_37e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSharedPresentSurfaceCapabilitiesKHR-sType-sType)"}, @@ -6435,4 +6591,114 @@ static std::unordered_map validation_error_map{ {VALIDATION_ERROR_38e1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerReductionModeCreateInfoEXT-pNext-pNext)"}, {VALIDATION_ERROR_38e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerReductionModeCreateInfoEXT-sType-sType)"}, {VALIDATION_ERROR_38e35001, "The spec valid usage text states 'reductionMode must be a valid VkSamplerReductionModeEXT value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSamplerReductionModeCreateInfoEXT-reductionMode-parameter)"}, + {VALIDATION_ERROR_39400b4c, "The spec valid usage text states 'The bits in handleTypes must be supported and compatible, as reported by VkExternalFencePropertiesKHR.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportFenceCreateInfoKHR-handleTypes-01446)"}, + {VALIDATION_ERROR_39409e01, "The spec valid usage text states 'handleTypes must be a valid combination of VkExternalFenceHandleTypeFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportFenceCreateInfoKHR-handleTypes-parameter)"}, + {VALIDATION_ERROR_3941c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportFenceCreateInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3942b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportFenceCreateInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_39609c01, "The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalFenceInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_3961c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalFenceInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3962b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceExternalFenceInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3981c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalFencePropertiesKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3982b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExternalFencePropertiesKHR-sType-sType)"}, + {VALIDATION_ERROR_39a27a01, "The spec valid usage text states 'physicalDevice must be a valid VkPhysicalDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalFencePropertiesKHR-physicalDevice-parameter)"}, + {VALIDATION_ERROR_39a3a201, "The spec valid usage text states 'pExternalFenceInfo must be a pointer to a valid VkPhysicalDeviceExternalFenceInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalFencePropertiesKHR-pExternalFenceInfo-parameter)"}, + {VALIDATION_ERROR_39a3a401, "The spec valid usage text states 'pExternalFenceProperties must be a pointer to a VkExternalFencePropertiesKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetPhysicalDeviceExternalFencePropertiesKHR-pExternalFenceProperties-parameter)"}, + {VALIDATION_ERROR_39c00b70, "The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportFenceFdInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-handleType-01464)"}, + {VALIDATION_ERROR_39c00b72, "The spec valid usage text states 'The fence from which handleType was exported must have been created on the same underlying physical device as fence.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-handleType-01465)"}, + {VALIDATION_ERROR_39c08801, "The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-fence-parameter)"}, + {VALIDATION_ERROR_39c09001, "The spec valid usage text states 'flags must be a valid combination of VkFenceImportFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-flags-parameter)"}, + {VALIDATION_ERROR_39c09c01, "The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_39c1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_39c2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceFdInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_39e00b5a, "The spec valid usage text states 'handleType must have been included in VkExportFenceCreateInfoKHR::handleTypes when fence's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-01453)"}, + {VALIDATION_ERROR_39e00b5c, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-01454)"}, + {VALIDATION_ERROR_39e00b5e, "The spec valid usage text states 'fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload's handle type was included in VkExternalFencePropertiesKHR::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-fence-01455)"}, + {VALIDATION_ERROR_39e00b60, "The spec valid usage text states 'handleType must be defined as a POSIX file descriptor handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-01456)"}, + {VALIDATION_ERROR_39e08801, "The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-fence-parameter)"}, + {VALIDATION_ERROR_39e09c01, "The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_39e1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_39e2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetFdInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3a000b6e, "The spec valid usage text states 'fence must not be associated with any queue command that has not yet completed execution on that queue' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportFenceFdKHR-fence-01463)"}, + {VALIDATION_ERROR_3a005601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportFenceFdKHR-device-parameter)"}, + {VALIDATION_ERROR_3a03a801, "The spec valid usage text states 'pImportFenceFdInfo must be a pointer to a valid VkImportFenceFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportFenceFdKHR-pImportFenceFdInfo-parameter)"}, + {VALIDATION_ERROR_3a205601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceFdKHR-device-parameter)"}, + {VALIDATION_ERROR_3a216c01, "The spec valid usage text states 'pFd must be a pointer to a int value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceFdKHR-pFd-parameter)"}, + {VALIDATION_ERROR_3a239e01, "The spec valid usage text states 'pGetFdInfo must be a pointer to a valid VkFenceGetFdInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceFdKHR-pGetFdInfo-parameter)"}, + {VALIDATION_ERROR_3a400b62, "The spec valid usage text states 'handleType must be a value included in the Handle Types Supported by VkImportFenceWin32HandleInfoKHR table.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01457)"}, + {VALIDATION_ERROR_3a400b64, "The spec valid usage text states 'The fence from which handleType or name was exported must have been created on the same underlying physical device as fence.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01458)"}, + {VALIDATION_ERROR_3a400b66, "The spec valid usage text states 'If handleType is not VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01459)"}, + {VALIDATION_ERROR_3a400b68, "The spec valid usage text states 'If handleType is not 0 and handle is NULL, name must name a valid synchronization primitive of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01460)"}, + {VALIDATION_ERROR_3a400b6a, "The spec valid usage text states 'If handleType is not 0 and name is NULL, handle must be a valid handle of the type specified by handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-01461)"}, + {VALIDATION_ERROR_3a400b6c, "The spec valid usage text states 'If handle is not NULL, name must be NULL.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handle-01462)"}, + {VALIDATION_ERROR_3a408801, "The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter)"}, + {VALIDATION_ERROR_3a409001, "The spec valid usage text states 'flags must be a valid combination of VkFenceImportFlagBitsKHR values' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter)"}, + {VALIDATION_ERROR_3a409c01, "The spec valid usage text states 'If handleType is not 0, handleType must be a valid VkExternalFenceHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_3a41c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3a42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImportFenceWin32HandleInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3a600b4e, "The spec valid usage text states 'If VkExportFenceCreateInfoKHR::handleTypes does not include VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, VkExportFenceWin32HandleInfoKHR must not be in the pNext chain of VkFenceCreateInfo.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-handleTypes-01447)"}, + {VALIDATION_ERROR_3a60f401, "The spec valid usage text states 'If pAttributes is not NULL, pAttributes must be a pointer to a valid SECURITY_ATTRIBUTES value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-pAttributes-parameter)"}, + {VALIDATION_ERROR_3a61c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3a62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkExportFenceWin32HandleInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3a800b50, "The spec valid usage text states 'handleType must have been included in VkExportFenceCreateInfoKHR::handleTypes when the fence's current payload was created.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01448)"}, + {VALIDATION_ERROR_3a800b52, "The spec valid usage text states 'If handleType is defined as an NT handle, vkGetFenceWin32HandleKHR must be called no more than once for each valid unique combination of fence and handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01449)"}, + {VALIDATION_ERROR_3a800b54, "The spec valid usage text states 'fence must not currently have its payload replaced by an imported payload as described below in Importing Fence Payloads unless that imported payload's handle type was included in VkExternalFencePropertiesKHR::exportFromImportedHandleTypes for handleType.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-fence-01450)"}, + {VALIDATION_ERROR_3a800b56, "The spec valid usage text states 'If handleType refers to a handle type with copy payload transference semantics, fence must be signaled, or have an associated fence signal operation pending execution.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01451)"}, + {VALIDATION_ERROR_3a800b58, "The spec valid usage text states 'handleType must be defined as an NT handle or a global share handle.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-01452)"}, + {VALIDATION_ERROR_3a808801, "The spec valid usage text states 'fence must be a valid VkFence handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter)"}, + {VALIDATION_ERROR_3a809c01, "The spec valid usage text states 'handleType must be a valid VkExternalFenceHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_3a81c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3a82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkFenceGetWin32HandleInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3aa05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportFenceWin32HandleKHR-device-parameter)"}, + {VALIDATION_ERROR_3aa3aa01, "The spec valid usage text states 'pImportFenceWin32HandleInfo must be a pointer to a valid VkImportFenceWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkImportFenceWin32HandleKHR-pImportFenceWin32HandleInfo-parameter)"}, + {VALIDATION_ERROR_3ac05601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceWin32HandleKHR-device-parameter)"}, + {VALIDATION_ERROR_3ac17c01, "The spec valid usage text states 'pHandle must be a pointer to a HANDLE value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceWin32HandleKHR-pHandle-parameter)"}, + {VALIDATION_ERROR_3ac3a001, "The spec valid usage text states 'pGetWin32HandleInfo must be a pointer to a valid VkFenceGetWin32HandleInfoKHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetFenceWin32HandleKHR-pGetWin32HandleInfo-parameter)"}, + {VALIDATION_ERROR_3ae09c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_3ae1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3ae2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3ae2b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter)"}, + {VALIDATION_ERROR_3b009c01, "The spec valid usage text states 'handleType must be a valid VkExternalSemaphoreHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_3b01c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3b02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3b02b801, "The spec valid usage text states 'semaphore must be a valid VkSemaphore handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter)"}, + {VALIDATION_ERROR_3b209c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_3b20c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-memory-parameter)"}, + {VALIDATION_ERROR_3b21c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3b22b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryGetFdInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3b409c01, "The spec valid usage text states 'handleType must be a valid VkExternalMemoryHandleTypeFlagBitsKHR value' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter)"}, + {VALIDATION_ERROR_3b40c601, "The spec valid usage text states 'memory must be a valid VkDeviceMemory handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter)"}, + {VALIDATION_ERROR_3b41c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3b42b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryGetWin32HandleInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3b61c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedRequirementsKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3b62b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedRequirementsKHR-sType-sType)"}, + {VALIDATION_ERROR_3b800009, "The spec valid usage text states 'Both of buffer, and image that are valid handles must have been created, allocated, or retrieved from the same VkDevice' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-commonparent)"}, + {VALIDATION_ERROR_3b800b30, "The spec valid usage text states 'At least one of image and buffer must be VK_NULL_HANDLE' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-image-01432)"}, + {VALIDATION_ERROR_3b800b32, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the image' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-image-01433)"}, + {VALIDATION_ERROR_3b800b34, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must have been created without VK_IMAGE_CREATE_SPARSE_BINDING_BIT set in VkImageCreateInfo::flags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-image-01434)"}, + {VALIDATION_ERROR_3b800b36, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, VkMemoryAllocateInfo::allocationSize must equal the VkMemoryRequirements::size of the buffer' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-buffer-01435)"}, + {VALIDATION_ERROR_3b800b38, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must have been created without VK_BUFFER_CREATE_SPARSE_BINDING_BIT set in VkBufferCreateInfo::flags' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-buffer-01436)"}, + {VALIDATION_ERROR_3b800b3a, "The spec valid usage text states 'If image is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated image allocation and image must be identical to the image associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-image-01437)"}, + {VALIDATION_ERROR_3b800b3c, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE and VkMemoryAllocateInfo defines a memory import operation, the memory being imported must also be a dedicated buffer allocation and buffer must be identical to the buffer associated with the imported memory.' (https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-buffer-01438)"}, + {VALIDATION_ERROR_3b801a01, "The spec valid usage text states 'If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-buffer-parameter)"}, + {VALIDATION_ERROR_3b80a001, "The spec valid usage text states 'If image is not VK_NULL_HANDLE, image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-image-parameter)"}, + {VALIDATION_ERROR_3b81c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3b82b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryDedicatedAllocateInfoKHR-sType-sType)"}, + {VALIDATION_ERROR_3ba01a01, "The spec valid usage text states 'buffer must be a valid VkBuffer handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryRequirementsInfo2KHR-buffer-parameter)"}, + {VALIDATION_ERROR_3ba1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryRequirementsInfo2KHR-pNext-pNext)"}, + {VALIDATION_ERROR_3ba2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkBufferMemoryRequirementsInfo2KHR-sType-sType)"}, + {VALIDATION_ERROR_3bc0a001, "The spec valid usage text states 'image must be a valid VkImage handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2KHR-image-parameter)"}, + {VALIDATION_ERROR_3bc1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2KHR-pNext-pNext)"}, + {VALIDATION_ERROR_3bc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkImageMemoryRequirementsInfo2KHR-sType-sType)"}, + {VALIDATION_ERROR_3c01c40d, "The spec valid usage text states 'pNext must be NULL or a pointer to a valid instance of VkMemoryDedicatedRequirementsKHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryRequirements2KHR-pNext-pNext)"}, + {VALIDATION_ERROR_3c02b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkMemoryRequirements2KHR-sType-sType)"}, + {VALIDATION_ERROR_3c405601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements2KHR-device-parameter)"}, + {VALIDATION_ERROR_3c41b401, "The spec valid usage text states 'pMemoryRequirements must be a pointer to a VkMemoryRequirements2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements2KHR-pMemoryRequirements-parameter)"}, + {VALIDATION_ERROR_3c439c01, "The spec valid usage text states 'pInfo must be a pointer to a valid VkImageMemoryRequirementsInfo2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetImageMemoryRequirements2KHR-pInfo-parameter)"}, + {VALIDATION_ERROR_3c605601, "The spec valid usage text states 'device must be a valid VkDevice handle' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements2KHR-device-parameter)"}, + {VALIDATION_ERROR_3c61b401, "The spec valid usage text states 'pMemoryRequirements must be a pointer to a VkMemoryRequirements2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements2KHR-pMemoryRequirements-parameter)"}, + {VALIDATION_ERROR_3c639c01, "The spec valid usage text states 'pInfo must be a pointer to a valid VkBufferMemoryRequirementsInfo2KHR structure' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-vkGetBufferMemoryRequirements2KHR-pInfo-parameter)"}, + {VALIDATION_ERROR_3ca2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDevice16BitStorageFeaturesKHR-sType-sType)"}, + {VALIDATION_ERROR_3cc00b2e, "The spec valid usage text states 'If variablePointers is enabled then variablePointersStorageBuffer must also be enabled.' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceVariablePointerFeaturesKHR-variablePointers-01431)"}, + {VALIDATION_ERROR_3cc1c40d, "The spec valid usage text states 'pNext must be NULL' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceVariablePointerFeaturesKHR-pNext-pNext)"}, + {VALIDATION_ERROR_3cc2b00b, "The spec valid usage text states 'sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR' (https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VUID-VkPhysicalDeviceVariablePointerFeaturesKHR-sType-sType)"}, }; diff --git a/layers/windows/VkLayer_core_validation.json b/layers/windows/VkLayer_core_validation.json index 35b2f092..1912cd98 100644 --- a/layers/windows/VkLayer_core_validation.json +++ b/layers/windows/VkLayer_core_validation.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_LUNARG_core_validation", "type": "GLOBAL", "library_path": ".\\VkLayer_core_validation.dll", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "LunarG Validation Layer", "instance_extensions": [ diff --git a/layers/windows/VkLayer_object_tracker.json b/layers/windows/VkLayer_object_tracker.json index d572edbc..053291fb 100644 --- a/layers/windows/VkLayer_object_tracker.json +++ b/layers/windows/VkLayer_object_tracker.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_LUNARG_object_tracker", "type": "GLOBAL", "library_path": ".\\VkLayer_object_tracker.dll", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "LunarG Validation Layer", "instance_extensions": [ diff --git a/layers/windows/VkLayer_parameter_validation.json b/layers/windows/VkLayer_parameter_validation.json index 5131b43b..b8aa6419 100644 --- a/layers/windows/VkLayer_parameter_validation.json +++ b/layers/windows/VkLayer_parameter_validation.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_LUNARG_parameter_validation", "type": "GLOBAL", "library_path": ".\\VkLayer_parameter_validation.dll", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "LunarG Validation Layer", "instance_extensions": [ diff --git a/layers/windows/VkLayer_standard_validation.json b/layers/windows/VkLayer_standard_validation.json index 6b52306e..e5f52394 100644 --- a/layers/windows/VkLayer_standard_validation.json +++ b/layers/windows/VkLayer_standard_validation.json @@ -3,7 +3,7 @@ "layer": { "name": "VK_LAYER_LUNARG_standard_validation", "type": "GLOBAL", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "LunarG Standard Validation", "component_layers": [ diff --git a/layers/windows/VkLayer_threading.json b/layers/windows/VkLayer_threading.json index ffd244c3..2dcd9fb5 100644 --- a/layers/windows/VkLayer_threading.json +++ b/layers/windows/VkLayer_threading.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_GOOGLE_threading", "type": "GLOBAL", "library_path": ".\\VkLayer_threading.dll", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "Google Validation Layer", "instance_extensions": [ diff --git a/layers/windows/VkLayer_unique_objects.json b/layers/windows/VkLayer_unique_objects.json index 82eca7c2..8a438b84 100644 --- a/layers/windows/VkLayer_unique_objects.json +++ b/layers/windows/VkLayer_unique_objects.json @@ -4,7 +4,7 @@ "name": "VK_LAYER_GOOGLE_unique_objects", "type": "GLOBAL", "library_path": ".\\VkLayer_unique_objects.dll", - "api_version": "1.0.51", + "api_version": "1.0.54", "implementation_version": "1", "description": "Google Validation Layer" } diff --git a/loader/extension_manual.c b/loader/extension_manual.c index f4ad56bd..ef62b52b 100644 --- a/loader/extension_manual.c +++ b/loader/extension_manual.c @@ -260,16 +260,16 @@ VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(VkPhysical void *pNext = pProperties->pNext; while (pNext != NULL) { switch (*(VkStructureType *)pNext) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX: { - VkPhysicalDeviceIDPropertiesKHX *id_properties = pNext; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: { + VkPhysicalDeviceIDPropertiesKHR *id_properties = pNext; - // Verify that "VK_KHX_external_memory_capabilities" is enabled - if (icd_term->this_instance->enabled_known_extensions.khx_external_memory_capabilities) { + // Verify that "VK_KHR_external_memory_capabilities" is enabled + if (icd_term->this_instance->enabled_known_extensions.khr_external_memory_capabilities) { loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "vkGetPhysicalDeviceProperties2KHR: Emulation cannot generate unique IDs for struct " - "VkPhysicalDeviceIDPropertiesKHX - setting IDs to zero instead"); + "VkPhysicalDeviceIDPropertiesKHR - setting IDs to zero instead"); - // Write to the VkPhysicalDeviceIDPropertiesKHX struct + // Write to the VkPhysicalDeviceIDPropertiesKHR struct memset(id_properties->deviceUUID, 0, VK_UUID_SIZE); memset(id_properties->driverUUID, 0, VK_UUID_SIZE); id_properties->deviceLUIDValid = VK_FALSE; @@ -797,6 +797,140 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDev #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT +// ---- VK_KHR_external_memory_capabilities extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo, + VkExternalBufferPropertiesKHR *pExternalBufferProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceExternalBufferPropertiesKHR(unwrapped_phys_dev, pExternalBufferInfo, pExternalBufferProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo, + VkExternalBufferPropertiesKHR *pExternalBufferProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceExternalBufferPropertiesKHR) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceExternalBufferPropertiesKHR(phys_dev_term->phys_dev, pExternalBufferInfo, + pExternalBufferProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalBufferPropertiesKHR: Emulating call in ICD \"%s\"", icd_term->scanned_icd->lib_name); + + if (pExternalBufferInfo->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalBufferPropertiesKHR: Emulation found unrecognized structure type in " + "pExternalBufferInfo->pNext - this struct will be ignored"); + } + + // Fill in everything being unsupported + memset(&pExternalBufferProperties->externalMemoryProperties, 0, sizeof(VkExternalMemoryPropertiesKHR)); + + if (pExternalBufferProperties->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalBufferPropertiesKHR: Emulation found unrecognized structure type in " + "pExternalBufferProperties->pNext - this struct will be ignored"); + } + } +} + +// ---- VK_KHR_external_semaphore_capabilities extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR *pExternalSemaphoreProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceExternalSemaphorePropertiesKHR(unwrapped_phys_dev, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR *pExternalSemaphoreProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceExternalSemaphorePropertiesKHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceExternalSemaphorePropertiesKHR(phys_dev_term->phys_dev, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: Emulating call in ICD \"%s\"", + icd_term->scanned_icd->lib_name); + + if (pExternalSemaphoreInfo->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: Emulation found unrecognized structure type in " + "pExternalSemaphoreInfo->pNext - this struct will be ignored"); + } + + // Fill in everything being unsupported + pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0; + pExternalSemaphoreProperties->compatibleHandleTypes = 0; + pExternalSemaphoreProperties->externalSemaphoreFeatures = 0; + + if (pExternalSemaphoreProperties->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: Emulation found unrecognized structure type in " + "pExternalSemaphoreProperties->pNext - this struct will be ignored"); + } + } +} + +// ---- VK_KHR_external_fence_capabilities extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR *pExternalFenceInfo, + VkExternalFencePropertiesKHR *pExternalFenceProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceExternalFencePropertiesKHR(unwrapped_phys_dev, pExternalFenceInfo, pExternalFenceProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR *pExternalFenceInfo, + VkExternalFencePropertiesKHR *pExternalFenceProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceExternalFencePropertiesKHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceExternalFencePropertiesKHR(phys_dev_term->phys_dev, pExternalFenceInfo, + pExternalFenceProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalFencePropertiesKHR: Emulating call in ICD \"%s\"", icd_term->scanned_icd->lib_name); + + if (pExternalFenceInfo->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalFencePropertiesKHR: Emulation found unrecognized structure type in " + "pExternalFenceInfo->pNext - this struct will be ignored"); + } + + // Fill in everything being unsupported + pExternalFenceProperties->exportFromImportedHandleTypes = 0; + pExternalFenceProperties->compatibleHandleTypes = 0; + pExternalFenceProperties->externalFenceFeatures = 0; + + if (pExternalFenceProperties->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalFencePropertiesKHR: Emulation found unrecognized structure type in " + "pExternalFenceProperties->pNext - this struct will be ignored"); + } + } +} + // ---- Helper functions VkResult setupLoaderTrampPhysDevGroups(VkInstance instance) { @@ -1208,4 +1342,4 @@ out: } return res; -} \ No newline at end of file +} diff --git a/loader/extension_manual.h b/loader/extension_manual.h index 9f9b85f4..3b299d55 100644 --- a/loader/extension_manual.h +++ b/loader/extension_manual.h @@ -134,3 +134,27 @@ VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physica VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, + VkExternalBufferPropertiesKHR* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, + VkExternalBufferPropertiesKHR* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, + VkExternalFencePropertiesKHR* pExternalFenceProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, + VkExternalFencePropertiesKHR* pExternalFenceProperties); diff --git a/scripts/helper_file_generator.py b/scripts/helper_file_generator.py index 27f4440b..895075bb 100644 --- a/scripts/helper_file_generator.py +++ b/scripts/helper_file_generator.py @@ -667,10 +667,7 @@ class HelperFileOutputGenerator(OutputGenerator): done = True break if done == False: - if object_type == 'kVulkanObjectTypeDebugReportCallbackEXT': - object_types_header += ' VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, // kVulkanObjectTypeDebugReportCallbackEXT\n' - else: - object_types_header += ' VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT; // No Match\n' + object_types_header += ' VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // No Match\n' object_types_header += '};\n' # Output a conversion routine from the layer object definitions to the core object type definitions @@ -688,7 +685,7 @@ class HelperFileOutputGenerator(OutputGenerator): done = True break if done == False: - object_types_header += ' VK_OBJECT_TYPE_UNKNOWN; // No Match\n' + object_types_header += ' VK_OBJECT_TYPE_UNKNOWN, // No Match\n' object_types_header += '};\n' return object_types_header diff --git a/scripts/loader_extension_generator.py b/scripts/loader_extension_generator.py index d9169140..84cc4ca4 100644 --- a/scripts/loader_extension_generator.py +++ b/scripts/loader_extension_generator.py @@ -848,7 +848,10 @@ class LoaderExtensionOutputGenerator(OutputGenerator): 'vkGetPhysicalDeviceSurfaceCapabilities2EXT', 'vkReleaseDisplayEXT', 'vkAcquireXlibDisplayEXT', - 'vkGetRandROutputDisplayEXT'] + 'vkGetRandROutputDisplayEXT', + 'vkGetPhysicalDeviceExternalBufferPropertiesKHR', + 'vkGetPhysicalDeviceExternalSemaphorePropertiesKHR', + 'vkGetPhysicalDeviceExternalFencePropertiesKHR'] for ext_cmd in self.ext_commands: if (ext_cmd.ext_name in WSI_EXT_NAMES or diff --git a/scripts/unique_objects_generator.py b/scripts/unique_objects_generator.py index 7effe03f..3af26fb0 100644 --- a/scripts/unique_objects_generator.py +++ b/scripts/unique_objects_generator.py @@ -147,6 +147,9 @@ class UniqueObjectsOutputGenerator(OutputGenerator): 'vkCmdPushDescriptorSetWithTemplateKHR', 'vkDebugMarkerSetObjectTagEXT', 'vkDebugMarkerSetObjectNameEXT', + 'vkGetPhysicalDeviceDisplayProperties2KHR', + 'vkGetPhysicalDeviceDisplayPlaneProperties2KHR', + 'vkGetDisplayModeProperties2KHR', ] # Commands shadowed by interface functions and are not implemented self.interface_functions = [ diff --git a/scripts/vk.xml b/scripts/vk.xml index 3959ca6f..3e0010bc 100644 --- a/scripts/vk.xml +++ b/scripts/vk.xml @@ -106,7 +106,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. // Vulkan 1.0 version number #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0) // Version of this file -#define VK_HEADER_VERSION 53 +#define VK_HEADER_VERSION 54 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; @@ -129,6 +129,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. typedef uint32_t VkBool32; typedef uint32_t VkFlags; typedef uint64_t VkDeviceSize; + @@ -227,10 +228,14 @@ private version is maintained in the 1.0 branch of the member gitlab server. typedef VkFlags VkCommandPoolTrimFlagsKHR; typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; typedef VkFlags VkExternalMemoryFeatureFlagsNV; - typedef VkFlags VkExternalMemoryHandleTypeFlagsKHX; - typedef VkFlags VkExternalMemoryFeatureFlagsKHX; - typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHX; - typedef VkFlags VkExternalSemaphoreFeatureFlagsKHX; + typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR; + typedef VkFlags VkExternalMemoryFeatureFlagsKHR; + typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR; + typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR; + typedef VkFlags VkSemaphoreImportFlagsKHR; + typedef VkFlags VkExternalFenceHandleTypeFlagsKHR; + typedef VkFlags VkExternalFenceFeatureFlagsKHR; + typedef VkFlags VkFenceImportFlagsKHR; typedef VkFlags VkSurfaceCounterFlagsEXT; typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; @@ -384,10 +389,14 @@ private version is maintained in the 1.0 branch of the member gitlab server. - - - - + + + + + + + + @@ -533,7 +542,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkDeviceCreateFlags flags uint32_t queueCreateInfoCount const VkDeviceQueueCreateInfo* pQueueCreateInfos @@ -545,7 +554,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkInstanceCreateFlags flags const VkApplicationInfo* pApplicationInfo uint32_t enabledLayerCount @@ -567,7 +576,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkDeviceSize allocationSize uint32_t memoryTypeIndex @@ -650,7 +659,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkBufferCreateFlags flags VkDeviceSize size VkBufferUsageFlags usage @@ -716,7 +725,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkImageCreateFlags flags VkImageType imageType VkFormat format @@ -929,7 +938,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkPipelineViewportStateCreateFlags flags uint32_t viewportCount const VkViewport* pViewports @@ -1014,7 +1023,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkPipelineCreateFlags flags uint32_t stageCount const VkPipelineShaderStageCreateInfo* pStages @@ -1168,7 +1177,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkRenderPassCreateFlags flags uint32_t attachmentCount const VkAttachmentDescription* pAttachments @@ -1184,7 +1193,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkFenceCreateFlags flags @@ -1370,7 +1379,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkSemaphoreCreateFlags flags @@ -1412,7 +1421,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext uint32_t waitSemaphoreCount const VkSemaphore* pWaitSemaphores const VkPipelineStageFlags* pWaitDstStageMask @@ -1544,7 +1553,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - const void* pNext + const void* pNext VkSwapchainCreateFlagsKHR flags VkSurfaceKHR surface uint32_t minImageCount @@ -1769,12 +1778,12 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - void* pNext + void* pNext VkPhysicalDeviceFeatures features VkStructureType sType - void* pNext + void* pNext VkPhysicalDeviceProperties properties @@ -1784,12 +1793,12 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkStructureType sType - void* pNext + void* pNext VkImageFormatProperties imageFormatProperties VkStructureType sType - const void* pNext + const void* pNext VkFormat format VkImageType type VkImageTiling tiling @@ -1840,87 +1849,107 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkExtent2D extent uint32_t layer - - VkExternalMemoryFeatureFlagsKHX externalMemoryFeatures - VkExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes - VkExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes + + VkStructureType sType + void* pNext + VkBool32 variablePointersStorageBuffer + VkBool32 variablePointers + + + VkExternalMemoryFeatureFlagsKHR externalMemoryFeatures + VkExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes - - VkStructureType sType + + VkStructureType sType const void* pNext - VkExternalMemoryHandleTypeFlagBitsKHX handleType + VkExternalMemoryHandleTypeFlagBitsKHR handleType - - VkStructureType sType + + VkStructureType sType void* pNext - VkExternalMemoryPropertiesKHX externalMemoryProperties + VkExternalMemoryPropertiesKHR externalMemoryProperties - - VkStructureType sType + + VkStructureType sType const void* pNext VkBufferCreateFlags flags VkBufferUsageFlags usage - VkExternalMemoryHandleTypeFlagBitsKHX handleType + VkExternalMemoryHandleTypeFlagBitsKHR handleType - - VkStructureType sType + + VkStructureType sType void* pNext - VkExternalMemoryPropertiesKHX externalMemoryProperties + VkExternalMemoryPropertiesKHR externalMemoryProperties - - VkStructureType sType + + VkStructureType sType void* pNext uint8_t deviceUUID[VK_UUID_SIZE] uint8_t driverUUID[VK_UUID_SIZE] - uint8_t deviceLUID[VK_LUID_SIZE_KHX] + uint8_t deviceLUID[VK_LUID_SIZE_KHR] + uint32_t deviceNodeMask VkBool32 deviceLUIDValid - - VkStructureType sType + + VkStructureType sType const void* pNext - VkExternalMemoryHandleTypeFlagsKHX handleTypes + VkExternalMemoryHandleTypeFlagsKHR handleTypes - - VkStructureType sType + + VkStructureType sType const void* pNext - VkExternalMemoryHandleTypeFlagsKHX handleTypes + VkExternalMemoryHandleTypeFlagsKHR handleTypes - - VkStructureType sType + + VkStructureType sType const void* pNext - VkExternalMemoryHandleTypeFlagsKHX handleTypes + VkExternalMemoryHandleTypeFlagsKHR handleTypes - - VkStructureType sType + + VkStructureType sType const void* pNext - VkExternalMemoryHandleTypeFlagBitsKHX handleType - HANDLE handle + VkExternalMemoryHandleTypeFlagBitsKHR handleType + HANDLE handle + LPCWSTR name - - VkStructureType sType + + VkStructureType sType const void* pNext const SECURITY_ATTRIBUTES* pAttributes DWORD dwAccess LPCWSTR name - - VkStructureType sType + + VkStructureType sType void* pNext uint32_t memoryTypeBits - - VkStructureType sType + + VkStructureType sType const void* pNext - VkExternalMemoryHandleTypeFlagBitsKHX handleType + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBitsKHR handleType + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBitsKHR handleType int fd - - VkStructureType sType + + VkStructureType sType void* pNext uint32_t memoryTypeBits - - VkStructureType sType + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBitsKHR handleType + + + VkStructureType sType const void* pNext uint32_t acquireCount const VkDeviceMemory* pAcquireSyncs @@ -1930,52 +1959,120 @@ private version is maintained in the 1.0 branch of the member gitlab server. const VkDeviceMemory* pReleaseSyncs const uint64_t* pReleaseKeys - - VkStructureType sType + + VkStructureType sType const void* pNext - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType - - VkStructureType sType + + VkStructureType sType void* pNext - VkExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes - VkExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes - VkExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures + VkExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes + VkExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes + VkExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures - - VkStructureType sType + + VkStructureType sType const void* pNext - VkExternalSemaphoreHandleTypeFlagsKHX handleTypes + VkExternalSemaphoreHandleTypeFlagsKHR handleTypes - - VkStructureType sType + + VkStructureType sType const void* pNext - VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagsKHX handleType - HANDLE handle - - - VkStructureType sType + VkSemaphore semaphore + VkSemaphoreImportFlagsKHR flags + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType const void* pNext const SECURITY_ATTRIBUTES* pAttributes DWORD dwAccess LPCWSTR name - - VkStructureType sType + + VkStructureType sType const void* pNext uint32_t waitSemaphoreValuesCount const uint64_t* pWaitSemaphoreValues uint32_t signalSemaphoreValuesCount const uint64_t* pSignalSemaphoreValues - - VkStructureType sType + + VkStructureType sType const void* pNext VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlagsKHR flags + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType int fd + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlagBitsKHR handleType + + + VkStructureType sType + void* pNext + VkExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes + VkExternalFenceHandleTypeFlagsKHR compatibleHandleTypes + VkExternalFenceFeatureFlagsKHR externalFenceFeatures + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlagsKHR handleTypes + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlagsKHR flags + VkExternalFenceHandleTypeFlagBitsKHR handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBitsKHR handleType + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlagsKHR flags + VkExternalFenceHandleTypeFlagBitsKHR handleType + int fd + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBitsKHR handleType + VkStructureType sType void* pNext @@ -2273,6 +2370,51 @@ private version is maintained in the 1.0 branch of the member gitlab server. void* pNext VkImageUsageFlags sharedPresentSupportedUsageFlags + + VkStructureType sType + void* pNext + VkBool32 storageBuffer16BitAccess + VkBool32 uniformAndStorageBuffer16BitAccess + VkBool32 storagePushConstant16 + VkBool32 storageInputOutput16 + + + VkStructureType sType + const void* pNext + VkBuffer buffer + + + VkStructureType sType + const void* pNext + VkImage image + + + VkStructureType sType + const void* pNext + VkImage image + + + VkStructureType sType + void* pNext + VkMemoryRequirements memoryRequirements + + + VkStructureType sType + void* pNext + VkSparseImageMemoryRequirements memoryRequirements + + + VkStructureType sType + void* pNext + VkBool32 prefersDedicatedAllocation + VkBool32 requiresDedicatedAllocation + + + VkStructureType sType + const void* pNext + VkImage image + VkBuffer buffer + VkStructureType sType void* pNext @@ -2335,7 +2477,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -2348,7 +2490,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + @@ -3216,30 +3358,46 @@ private version is maintained in the 1.0 branch of the member gitlab server. - - - - - - - - + + + + + + + + - - - - + + + + - - - - - - + + + + + + - - - + + + + + + + + + + + + + + + + + + + @@ -3432,7 +3590,7 @@ private version is maintained in the 1.0 branch of the member gitlab server. all sname:VkQueue objects created from pname:device - + VkResult vkAllocateMemory VkDevice device const VkMemoryAllocateInfo* pAllocateInfo @@ -4656,68 +4814,92 @@ private version is maintained in the 1.0 branch of the member gitlab server. VkCommandPoolTrimFlagsKHR flags - void vkGetPhysicalDeviceExternalBufferPropertiesKHX + void vkGetPhysicalDeviceExternalBufferPropertiesKHR VkPhysicalDevice physicalDevice - const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo - VkExternalBufferPropertiesKHX* pExternalBufferProperties + const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo + VkExternalBufferPropertiesKHR* pExternalBufferProperties - VkResult vkGetMemoryWin32HandleKHX + VkResult vkGetMemoryWin32HandleKHR VkDevice device - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagBitsKHX handleType + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo HANDLE* pHandle - - VkResult vkGetMemoryWin32HandlePropertiesKHX + + VkResult vkGetMemoryWin32HandlePropertiesKHR VkDevice device - VkExternalMemoryHandleTypeFlagBitsKHX handleType + VkExternalMemoryHandleTypeFlagBitsKHR handleType HANDLE handle - VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties - VkResult vkGetMemoryFdKHX + VkResult vkGetMemoryFdKHR VkDevice device - VkDeviceMemory memory - VkExternalMemoryHandleTypeFlagBitsKHX handleType + const VkMemoryGetFdInfoKHR* pGetFdInfo int* pFd - - VkResult vkGetMemoryFdPropertiesKHX + + VkResult vkGetMemoryFdPropertiesKHR VkDevice device - VkExternalMemoryHandleTypeFlagBitsKHX handleType + VkExternalMemoryHandleTypeFlagBitsKHR handleType int fd - VkMemoryFdPropertiesKHX* pMemoryFdProperties + VkMemoryFdPropertiesKHR* pMemoryFdProperties + + + void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties + + + VkResult vkGetSemaphoreWin32HandleKHR + VkDevice device + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkImportSemaphoreWin32HandleKHR + VkDevice device + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo + + + VkResult vkGetSemaphoreFdKHR + VkDevice device + const VkSemaphoreGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkImportSemaphoreFdKHR + VkDevice device + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo - void vkGetPhysicalDeviceExternalSemaphorePropertiesKHX + void vkGetPhysicalDeviceExternalFencePropertiesKHR VkPhysicalDevice physicalDevice - const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo - VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties + const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo + VkExternalFencePropertiesKHR* pExternalFenceProperties - VkResult vkGetSemaphoreWin32HandleKHX + VkResult vkGetFenceWin32HandleKHR VkDevice device - VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo HANDLE* pHandle - - VkResult vkImportSemaphoreWin32HandleKHX + + VkResult vkImportFenceWin32HandleKHR VkDevice device - const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo - VkResult vkGetSemaphoreFdKHX + VkResult vkGetFenceFdKHR VkDevice device - VkSemaphore semaphore - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType + const VkFenceGetFdInfoKHR* pGetFdInfo int* pFd - - VkResult vkImportSemaphoreFdKHX + + VkResult vkImportFenceFdKHR VkDevice device - const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo + const VkImportFenceFdInfoKHR* pImportFenceFdInfo VkResult vkReleaseDisplayEXT @@ -4930,6 +5112,25 @@ private version is maintained in the 1.0 branch of the member gitlab server. uint32_t* pSurfaceFormatCount VkSurfaceFormat2KHR* pSurfaceFormats + + void vkGetBufferMemoryRequirements2KHR + VkDevice device + const VkBufferMemoryRequirementsInfo2KHR* pInfo + VkMemoryRequirements2KHR* pMemoryRequirements + + + void vkGetImageMemoryRequirements2KHR + VkDevice device + const VkImageMemoryRequirementsInfo2KHR* pInfo + VkMemoryRequirements2KHR* pMemoryRequirements + + + void vkGetImageSparseMemoryRequirements2KHR + VkDevice device + const VkImageSparseMemoryRequirementsInfo2KHR* pInfo + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements + @@ -5826,124 +6027,134 @@ private version is maintained in the 1.0 branch of the member gitlab server. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -5968,10 +6179,12 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - + + + + @@ -6275,28 +6488,57 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - + + + + + + + + + + + + + - + - - + + + + + + - + - - + + + + + + + + + + - + - - + + + + + + + + @@ -6331,10 +6573,12 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - + + + + @@ -6381,10 +6625,14 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - + + + + + + @@ -6411,10 +6659,10 @@ private version is maintained in the 1.0 branch of the member gitlab server. - + - - + + @@ -6501,10 +6749,23 @@ private version is maintained in the 1.0 branch of the member gitlab server. - - - - + + + + + + + + + + + + + + + + + diff --git a/scripts/vuid_mapping.py b/scripts/vuid_mapping.py index 78c620fd..65165d60 100644 --- a/scripts/vuid_mapping.py +++ b/scripts/vuid_mapping.py @@ -79,7 +79,7 @@ func_struct_id_map = { 'VkComponentMapping' : 23, 'VkComputePipelineCreateInfo' : 24, 'VkCopyDescriptorSet' : 25, -'VkD3D12FenceSubmitInfoKHX' : 26, +'VkD3D12FenceSubmitInfoKHR' : 26, 'VkDebugMarkerMarkerInfoEXT' : 27, 'VkDebugMarkerObjectNameInfoEXT' : 28, 'VkDebugMarkerObjectTagInfoEXT' : 29, @@ -117,14 +117,14 @@ func_struct_id_map = { 'VkDrawIndexedIndirectCommand' : 61, 'VkDrawIndirectCommand' : 62, 'VkEventCreateInfo' : 63, -'VkExportMemoryAllocateInfoKHX' : 64, +'VkExportMemoryAllocateInfoKHR' : 64, 'VkExportMemoryAllocateInfoNV' : 65, -'VkExportMemoryWin32HandleInfoKHX' : 66, +'VkExportMemoryWin32HandleInfoKHR' : 66, 'VkExportMemoryWin32HandleInfoNV' : 67, -'VkExportSemaphoreCreateInfoKHX' : 68, -'VkExportSemaphoreWin32HandleInfoKHX' : 69, -'VkExternalMemoryBufferCreateInfoKHX' : 70, -'VkExternalMemoryImageCreateInfoKHX' : 71, +'VkExportSemaphoreCreateInfoKHR' : 68, +'VkExportSemaphoreWin32HandleInfoKHR' : 69, +'VkExternalMemoryBufferCreateInfoKHR' : 70, +'VkExternalMemoryImageCreateInfoKHR' : 71, 'VkExternalMemoryImageCreateInfoNV' : 72, 'VkFenceCreateInfo' : 73, 'VkFramebufferCreateInfo' : 74, @@ -140,11 +140,11 @@ func_struct_id_map = { 'VkImageSubresourceRange' : 84, 'VkImageSwapchainCreateInfoKHX' : 85, 'VkImageViewCreateInfo' : 86, -'VkImportMemoryFdInfoKHX' : 87, -'VkImportMemoryWin32HandleInfoKHX' : 88, +'VkImportMemoryFdInfoKHR' : 87, +'VkImportMemoryWin32HandleInfoKHR' : 88, 'VkImportMemoryWin32HandleInfoNV' : 89, -'VkImportSemaphoreFdInfoKHX' : 90, -'VkImportSemaphoreWin32HandleInfoKHX' : 91, +'VkImportSemaphoreFdInfoKHR' : 90, +'VkImportSemaphoreWin32HandleInfoKHR' : 91, 'VkIndirectCommandsLayoutCreateInfoNVX' : 92, 'VkIndirectCommandsLayoutTokenNVX' : 93, 'VkIndirectCommandsTokenNVX' : 94, @@ -163,9 +163,9 @@ func_struct_id_map = { 'VkObjectTablePushConstantEntryNVX' : 107, 'VkObjectTableVertexBufferEntryNVX' : 108, 'VkPhysicalDeviceDiscardRectanglePropertiesEXT' : 109, -'VkPhysicalDeviceExternalBufferInfoKHX' : 110, -'VkPhysicalDeviceExternalImageFormatInfoKHX' : 111, -'VkPhysicalDeviceExternalSemaphoreInfoKHX' : 112, +'VkPhysicalDeviceExternalBufferInfoKHR' : 110, +'VkPhysicalDeviceExternalImageFormatInfoKHR' : 111, +'VkPhysicalDeviceExternalSemaphoreInfoKHR' : 112, 'VkPhysicalDeviceFeatures' : 113, 'VkPhysicalDeviceFeatures2KHR' : 114, 'VkPhysicalDeviceImageFormatInfo2KHR' : 115, @@ -224,7 +224,7 @@ func_struct_id_map = { 'VkViewport' : 168, 'VkViewportSwizzleNV' : 169, 'VkWaylandSurfaceCreateInfoKHR' : 170, -'VkWin32KeyedMutexAcquireReleaseInfoKHX' : 171, +'VkWin32KeyedMutexAcquireReleaseInfoKHR' : 171, 'VkWin32KeyedMutexAcquireReleaseInfoNV' : 172, 'VkWin32SurfaceCreateInfoKHR' : 173, 'VkWriteDescriptorSet' : 174, @@ -394,17 +394,17 @@ func_struct_id_map = { 'vkGetImageSparseMemoryRequirements' : 338, 'vkGetImageSubresourceLayout' : 339, 'vkGetInstanceProcAddr' : 340, -'vkGetMemoryFdKHX' : 341, -'vkGetMemoryFdPropertiesKHX' : 342, -'vkGetMemoryWin32HandleKHX' : 343, +'vkGetMemoryFdKHR' : 341, +'vkGetMemoryFdPropertiesKHR' : 342, +'vkGetMemoryWin32HandleKHR' : 343, 'vkGetMemoryWin32HandleNV' : 344, -'vkGetMemoryWin32HandlePropertiesKHX' : 345, +'vkGetMemoryWin32HandlePropertiesKHR' : 345, 'vkGetPastPresentationTimingGOOGLE' : 346, 'vkGetPhysicalDeviceDisplayPlanePropertiesKHR' : 347, 'vkGetPhysicalDeviceDisplayPropertiesKHR' : 348, -'vkGetPhysicalDeviceExternalBufferPropertiesKHX' : 349, +'vkGetPhysicalDeviceExternalBufferPropertiesKHR' : 349, 'vkGetPhysicalDeviceExternalImageFormatPropertiesNV' : 350, -'vkGetPhysicalDeviceExternalSemaphorePropertiesKHX' : 351, +'vkGetPhysicalDeviceExternalSemaphorePropertiesKHR' : 351, 'vkGetPhysicalDeviceFeatures' : 352, 'vkGetPhysicalDeviceFeatures2KHR' : 353, 'vkGetPhysicalDeviceFormatProperties' : 354, @@ -438,13 +438,13 @@ func_struct_id_map = { 'vkGetRandROutputDisplayEXT' : 382, 'vkGetRefreshCycleDurationGOOGLE' : 383, 'vkGetRenderAreaGranularity' : 384, -'vkGetSemaphoreFdKHX' : 385, -'vkGetSemaphoreWin32HandleKHX' : 386, +'vkGetSemaphoreFdKHR' : 385, +'vkGetSemaphoreWin32HandleKHR' : 386, 'vkGetSwapchainCounterEXT' : 387, 'vkGetSwapchainImagesKHR' : 388, 'vkGetSwapchainStatusKHR' : 389, -'vkImportSemaphoreFdKHX' : 390, -'vkImportSemaphoreWin32HandleKHX' : 391, +'vkImportSemaphoreFdKHR' : 390, +'vkImportSemaphoreWin32HandleKHR' : 391, 'vkInvalidateMappedMemoryRanges' : 392, 'vkMapMemory' : 393, 'vkMergePipelineCaches' : 394, @@ -475,21 +475,21 @@ func_struct_id_map = { 'VkPhysicalDeviceMemoryProperties2KHR' : 419, 'VkSurfaceCapabilities2KHR' : 420, 'VkDeviceGroupPresentCapabilitiesKHX' : 421, -'VkExternalBufferPropertiesKHX' : 422, -'VkMemoryWin32HandlePropertiesKHX' : 423, -'VkMemoryFdPropertiesKHX' : 424, -'VkExternalSemaphorePropertiesKHX' : 425, +'VkExternalBufferPropertiesKHR' : 422, +'VkMemoryWin32HandlePropertiesKHR' : 423, +'VkMemoryFdPropertiesKHR' : 424, +'VkExternalSemaphorePropertiesKHR' : 425, 'VkQueueFamilyProperties2KHR' : 426, 'VkSparseImageFormatProperties2KHR' : 427, 'VkSurfaceFormat2KHR' : 428, 'VkTextureLODGatherFormatPropertiesAMD' : 429, 'VkPhysicalDeviceMultiviewPropertiesKHX' : 430, 'VkPhysicalDeviceGroupPropertiesKHX' : 431, -'VkExternalImageFormatPropertiesKHX' : 432, -'VkPhysicalDeviceIDPropertiesKHX' : 433, +'VkExternalImageFormatPropertiesKHR' : 432, +'VkPhysicalDeviceIDPropertiesKHR' : 433, 'VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX' : 434, 'VkHdrMetadataEXT' : 435, -'VkExternalMemoryPropertiesKHX' : 436, +'VkExternalMemoryPropertiesKHR' : 436, 'VkFormatProperties' : 437, 'VkImageFormatProperties' : 438, 'VkPhysicalDeviceLimits' : 439, @@ -511,6 +511,35 @@ func_struct_id_map = { 'VkSamplerReductionModeCreateInfoEXT' : 455, 'VkPhysicalDeviceProperties' : 456, 'VkSurfaceFormatKHR' : 457, +'VkExportFenceCreateInfoKHR' : 458, +'VkPhysicalDeviceExternalFenceInfoKHR' : 459, +'VkExternalFencePropertiesKHR' : 460, +'vkGetPhysicalDeviceExternalFencePropertiesKHR' : 461, +'VkImportFenceFdInfoKHR' : 462, +'VkFenceGetFdInfoKHR' : 463, +'vkImportFenceFdKHR' : 464, +'vkGetFenceFdKHR' : 465, +'VkImportFenceWin32HandleInfoKHR' : 466, +'VkExportFenceWin32HandleInfoKHR' : 467, +'VkFenceGetWin32HandleInfoKHR' : 468, +'vkImportFenceWin32HandleKHR' : 469, +'vkGetFenceWin32HandleKHR' : 470, +'VkSemaphoreGetFdInfoKHR' : 471, +'VkSemaphoreGetWin32HandleInfoKHR' : 472, +'VkMemoryGetFdInfoKHR' : 473, +'VkMemoryGetWin32HandleInfoKHR' : 474, +'VkMemoryDedicatedRequirementsKHR' : 475, +'VkMemoryDedicatedAllocateInfoKHR' : 476, +'VkBufferMemoryRequirementsInfo2KHR' : 477, +'VkImageMemoryRequirementsInfo2KHR' : 478, +'VkImageSparseMemoryRequirementsInfo2KHR' : 479, +'VkMemoryRequirements2KHR' : 480, +'VkSparseImageMemoryRequirements2KHR' : 481, +'vkGetImageMemoryRequirements2KHR' : 482, +'vkGetBufferMemoryRequirements2KHR' : 483, +'vkGetImageSparseMemoryRequirements2KHR' : 484, +'VkPhysicalDevice16BitStorageFeaturesKHR' : 485, +'VkPhysicalDeviceVariablePointerFeaturesKHR' : 486, ### ADD New func/struct mappings above this line } # Mapping of params to unique IDs @@ -976,6 +1005,15 @@ implicit_param_map = { 'blendConstants' : 458, 'displayName' : 459, 'pfnCallback' : 460, +'externalFenceFeatures' : 461, +'pInfo' : 462, +'pGetFdInfo' : 463, +'pGetWin32HandleInfo' : 464, +'pExternalFenceInfo' : 465, +'pExternalFenceProperties' : 466, +'pImportFenceProperties' : 467, +'pImportFenceFdInfo' : 468, +'pImportFenceWin32HandleInfo' : 469, ### ADD New implicit param mappings above this line } -- cgit v1.2.3