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 +++++++++++++++++++++++++------------------- 2 files changed, 7379 insertions(+), 5375 deletions(-) (limited to 'include/vulkan') 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) + "}"; } -- cgit v1.2.3