nihui
/
ncnn
Not watched
1
0
Fork 0
Code
Releases 46 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: c6ab155a67
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c6ab155a67'
${ noResults }
ncnn/src/vulkan_header_fix.h

1388 lines
75 kB
Raw Blame History 

  1. // Tencent is pleased to support the open source community by making ncnn available.

  2. //

  3. // Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.

  4. //

  5. // Licensed under the BSD 3-Clause License (the "License"); you may not use this file except

  6. // in compliance with the License. You may obtain a copy of the License at

  7. //

  8. // https://opensource.org/licenses/BSD-3-Clause

  9. //

  10. // Unless required by applicable law or agreed to in writing, software distributed

  11. // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR

  12. // CONDITIONS OF ANY KIND, either express or implied. See the License for the

  13. // specific language governing permissions and limitations under the License.

  14. 

  15. #ifndef NCNN_VULKAN_HEADER_FIX_H

  16. #define NCNN_VULKAN_HEADER_FIX_H

  17. 

  18. // #include "platform.h"

  19. 

  20. // This header contains new structure and function declearation to fix build with old vulkan sdk

  21. 

  22. #ifndef VK_KHR_maintenance1

  23. #define VK_KHR_maintenance1 1

  24. typedef VkFlags VkCommandPoolTrimFlags;

  25. typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;

  26. typedef void(VKAPI_PTR* PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);

  27. typedef PFN_vkTrimCommandPool PFN_vkTrimCommandPoolKHR;

  28. #endif // VK_KHR_maintenance1

  29. 

  30. #ifndef VK_KHR_get_physical_device_properties2

  31. #define VK_KHR_get_physical_device_properties2                    1

  32. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2              (VkStructureType)1000059000

  33. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2            (VkStructureType)1000059001

  34. #define VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2                     (VkStructureType)1000059002

  35. #define VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2               (VkStructureType)1000059003

  36. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2     (VkStructureType)1000059004

  37. #define VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2               (VkStructureType)1000059005

  38. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2     (VkStructureType)1000059006

  39. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR          VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2

  40. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2

  41. #define VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR                 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2

  42. #define VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR           VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2

  43. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2

  44. #define VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR           VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2

  45. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2

  46. typedef struct VkPhysicalDeviceFeatures2

  47. {

  48.     VkStructureType sType;

  49.     void* pNext;

  50.     VkPhysicalDeviceFeatures features;

  51. } VkPhysicalDeviceFeatures2;

  52. typedef struct VkPhysicalDeviceProperties2

  53. {

  54.     VkStructureType sType;

  55.     void* pNext;

  56.     VkPhysicalDeviceProperties properties;

  57. } VkPhysicalDeviceProperties2;

  58. typedef struct VkFormatProperties2

  59. {

  60.     VkStructureType sType;

  61.     void* pNext;

  62.     VkFormatProperties formatProperties;

  63. } VkFormatProperties2;

  64. typedef struct VkImageFormatProperties2

  65. {

  66.     VkStructureType sType;

  67.     void* pNext;

  68.     VkImageFormatProperties imageFormatProperties;

  69. } VkImageFormatProperties2;

  70. typedef struct VkPhysicalDeviceImageFormatInfo2

  71. {

  72.     VkStructureType sType;

  73.     const void* pNext;

  74.     VkFormat format;

  75.     VkImageType type;

  76.     VkImageTiling tiling;

  77.     VkImageUsageFlags usage;

  78.     VkImageCreateFlags flags;

  79. } VkPhysicalDeviceImageFormatInfo2;

  80. typedef struct VkQueueFamilyProperties2

  81. {

  82.     VkStructureType sType;

  83.     void* pNext;

  84.     VkQueueFamilyProperties queueFamilyProperties;

  85. } VkQueueFamilyProperties2;

  86. typedef struct VkPhysicalDeviceMemoryProperties2

  87. {

  88.     VkStructureType sType;

  89.     void* pNext;

  90.     VkPhysicalDeviceMemoryProperties memoryProperties;

  91. } VkPhysicalDeviceMemoryProperties2;

  92. typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;

  93. typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;

  94. typedef VkFormatProperties2 VkFormatProperties2KHR;

  95. typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;

  96. typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;

  97. typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;

  98. typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;

  99. typedef void(VKAPI_PTR* PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);

  100. typedef void(VKAPI_PTR* PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);

  101. typedef void(VKAPI_PTR* PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);

  102. typedef VkResult(VKAPI_PTR* PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);

  103. typedef void(VKAPI_PTR* PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);

  104. typedef void(VKAPI_PTR* PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);

  105. typedef PFN_vkGetPhysicalDeviceFeatures2 PFN_vkGetPhysicalDeviceFeatures2KHR;

  106. typedef PFN_vkGetPhysicalDeviceProperties2 PFN_vkGetPhysicalDeviceProperties2KHR;

  107. typedef PFN_vkGetPhysicalDeviceFormatProperties2 PFN_vkGetPhysicalDeviceFormatProperties2KHR;

  108. typedef PFN_vkGetPhysicalDeviceImageFormatProperties2 PFN_vkGetPhysicalDeviceImageFormatProperties2KHR;

  109. typedef PFN_vkGetPhysicalDeviceQueueFamilyProperties2 PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR;

  110. typedef PFN_vkGetPhysicalDeviceMemoryProperties2 PFN_vkGetPhysicalDeviceMemoryProperties2KHR;

  111. #endif // VK_KHR_get_physical_device_properties2

  112. 

  113. #ifndef VK_KHR_external_memory_capabilities

  114. #define VK_KHR_external_memory_capabilities                              1

  115. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO     (VkStructureType)1000071000

  116. #define VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES               (VkStructureType)1000071001

  117. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO           (VkStructureType)1000071002

  118. #define VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES                     (VkStructureType)1000071003

  119. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES                  (VkStructureType)1000071004

  120. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO

  121. #define VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR           VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES

  122. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO

  123. #define VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR                 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES

  124. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR              VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES

  125. #define VK_LUID_SIZE                                                     8

  126. #define VK_LUID_SIZE_KHR                                                 VK_LUID_SIZE

  127. typedef enum VkExternalMemoryHandleTypeFlagBits

  128. {

  129.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,

  130.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,

  131.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,

  132.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,

  133.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,

  134.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,

  135.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,

  136.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,

  137.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,

  138.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,

  139.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,

  140.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800,

  141.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000,

  142.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,

  143.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,

  144.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,

  145.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,

  146.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,

  147.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,

  148.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,

  149.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

  150. } VkExternalMemoryHandleTypeFlagBits;

  151. typedef VkFlags VkExternalMemoryHandleTypeFlags;

  152. typedef enum VkExternalMemoryFeatureFlagBits

  153. {

  154.     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,

  155.     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,

  156.     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,

  157.     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,

  158.     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,

  159.     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,

  160.     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

  161. } VkExternalMemoryFeatureFlagBits;

  162. typedef VkFlags VkExternalMemoryFeatureFlags;

  163. typedef struct VkExternalMemoryProperties

  164. {

  165.     VkExternalMemoryFeatureFlags externalMemoryFeatures;

  166.     VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;

  167.     VkExternalMemoryHandleTypeFlags compatibleHandleTypes;

  168. } VkExternalMemoryProperties;

  169. typedef struct VkPhysicalDeviceExternalImageFormatInfo

  170. {

  171.     VkStructureType sType;

  172.     const void* pNext;

  173.     VkExternalMemoryHandleTypeFlagBits handleType;

  174. } VkPhysicalDeviceExternalImageFormatInfo;

  175. typedef struct VkExternalImageFormatProperties

  176. {

  177.     VkStructureType sType;

  178.     void* pNext;

  179.     VkExternalMemoryProperties externalMemoryProperties;

  180. } VkExternalImageFormatProperties;

  181. typedef struct VkPhysicalDeviceExternalBufferInfo

  182. {

  183.     VkStructureType sType;

  184.     const void* pNext;

  185.     VkBufferCreateFlags flags;

  186.     VkBufferUsageFlags usage;

  187.     VkExternalMemoryHandleTypeFlagBits handleType;

  188. } VkPhysicalDeviceExternalBufferInfo;

  189. typedef struct VkExternalBufferProperties

  190. {

  191.     VkStructureType sType;

  192.     void* pNext;

  193.     VkExternalMemoryProperties externalMemoryProperties;

  194. } VkExternalBufferProperties;

  195. typedef struct VkPhysicalDeviceIDProperties

  196. {

  197.     VkStructureType sType;

  198.     void* pNext;

  199.     uint8_t deviceUUID[VK_UUID_SIZE];

  200.     uint8_t driverUUID[VK_UUID_SIZE];

  201.     uint8_t deviceLUID[VK_LUID_SIZE];

  202.     uint32_t deviceNodeMask;

  203.     VkBool32 deviceLUIDValid;

  204. } VkPhysicalDeviceIDProperties;

  205. typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;

  206. typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;

  207. typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;

  208. typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;

  209. typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;

  210. typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;

  211. typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;

  212. typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;

  213. typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;

  214. typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;

  215. typedef void(VKAPI_PTR* PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);

  216. typedef PFN_vkGetPhysicalDeviceExternalBufferProperties PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR;

  217. #endif // VK_KHR_external_memory_capabilities

  218. 

  219. #ifndef VK_KHR_external_memory

  220. #define VK_KHR_external_memory                                   1

  221. #define VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO     (VkStructureType)1000072000

  222. #define VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO      (VkStructureType)1000072001

  223. #define VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO            (VkStructureType)1000072002

  224. #define VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO

  225. #define VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR  VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO

  226. #define VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR        VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO

  227. #define VK_QUEUE_FAMILY_EXTERNAL_KHR                             (~0U - 1)

  228. typedef struct VkExternalMemoryImageCreateInfo

  229. {

  230.     VkStructureType sType;

  231.     const void* pNext;

  232.     VkExternalMemoryHandleTypeFlags handleTypes;

  233. } VkExternalMemoryImageCreateInfo;

  234. typedef struct VkExternalMemoryBufferCreateInfo

  235. {

  236.     VkStructureType sType;

  237.     const void* pNext;

  238.     VkExternalMemoryHandleTypeFlags handleTypes;

  239. } VkExternalMemoryBufferCreateInfo;

  240. typedef struct VkExportMemoryAllocateInfo

  241. {

  242.     VkStructureType sType;

  243.     const void* pNext;

  244.     VkExternalMemoryHandleTypeFlags handleTypes;

  245. } VkExportMemoryAllocateInfo;

  246. typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;

  247. typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;

  248. typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;

  249. #endif // VK_KHR_external_memory

  250. 

  251. #ifndef VK_KHR_descriptor_update_template

  252. #define VK_KHR_descriptor_update_template                            1

  253. #define VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO     (VkStructureType)1000085000

  254. #define VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO

  255. VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)

  256. typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;

  257. typedef enum VkDescriptorUpdateTemplateType

  258. {

  259.     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,

  260.     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,

  261.     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,

  262.     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF

  263. } VkDescriptorUpdateTemplateType;

  264. typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;

  265. typedef struct VkDescriptorUpdateTemplateEntry

  266. {

  267.     uint32_t dstBinding;

  268.     uint32_t dstArrayElement;

  269.     uint32_t descriptorCount;

  270.     VkDescriptorType descriptorType;

  271.     size_t offset;

  272.     size_t stride;

  273. } VkDescriptorUpdateTemplateEntry;

  274. typedef struct VkDescriptorUpdateTemplateCreateInfo

  275. {

  276.     VkStructureType sType;

  277.     void* pNext;

  278.     VkDescriptorUpdateTemplateCreateFlags flags;

  279.     uint32_t descriptorUpdateEntryCount;

  280.     const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;

  281.     VkDescriptorUpdateTemplateType templateType;

  282.     VkDescriptorSetLayout descriptorSetLayout;

  283.     VkPipelineBindPoint pipelineBindPoint;

  284.     VkPipelineLayout pipelineLayout;

  285.     uint32_t set;

  286. } VkDescriptorUpdateTemplateCreateInfo;

  287. typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;

  288. typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;

  289. typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;

  290. typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;

  291. typedef VkResult(VKAPI_PTR* PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);

  292. typedef void(VKAPI_PTR* PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);

  293. typedef void(VKAPI_PTR* PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);

  294. typedef PFN_vkCreateDescriptorUpdateTemplate PFN_vkCreateDescriptorUpdateTemplateKHR;

  295. typedef PFN_vkDestroyDescriptorUpdateTemplate PFN_vkDestroyDescriptorUpdateTemplateKHR;

  296. typedef PFN_vkUpdateDescriptorSetWithTemplate PFN_vkUpdateDescriptorSetWithTemplateKHR;

  297. #endif // VK_KHR_descriptor_update_template

  298. 

  299. #ifndef VK_KHR_push_descriptor

  300. #define VK_KHR_push_descriptor                                           1

  301. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR (VkStructureType)1000080000

  302. typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR

  303. {

  304.     VkStructureType sType;

  305.     void* pNext;

  306.     uint32_t maxPushDescriptors;

  307. } VkPhysicalDevicePushDescriptorPropertiesKHR;

  308. typedef void(VKAPI_PTR* PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);

  309. typedef void(VKAPI_PTR* PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);

  310. #endif // VK_KHR_push_descriptor

  311. 

  312. #ifndef VK_KHR_get_surface_capabilities2

  313. #define VK_KHR_get_surface_capabilities2                     1

  314. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR (VkStructureType)1000119000

  315. #define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR         (VkStructureType)1000119001

  316. #define VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR               (VkStructureType)1000119002

  317. typedef struct VkPhysicalDeviceSurfaceInfo2KHR

  318. {

  319.     VkStructureType sType;

  320.     const void* pNext;

  321.     VkSurfaceKHR surface;

  322. } VkPhysicalDeviceSurfaceInfo2KHR;

  323. typedef struct VkSurfaceCapabilities2KHR

  324. {

  325.     VkStructureType sType;

  326.     void* pNext;

  327.     VkSurfaceCapabilitiesKHR surfaceCapabilities;

  328. } VkSurfaceCapabilities2KHR;

  329. typedef struct VkSurfaceFormat2KHR

  330. {

  331.     VkStructureType sType;

  332.     void* pNext;

  333.     VkSurfaceFormatKHR surfaceFormat;

  334. } VkSurfaceFormat2KHR;

  335. typedef VkResult(VKAPI_PTR* PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);

  336. typedef VkResult(VKAPI_PTR* PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);

  337. #endif // VK_KHR_get_surface_capabilities2

  338. 

  339. #ifndef VK_KHR_external_memory_capabilities

  340. #define VK_KHR_external_memory_capabilities                              1

  341. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO     (VkStructureType)1000071000

  342. #define VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES               (VkStructureType)1000071001

  343. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO           (VkStructureType)1000071002

  344. #define VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES                     (VkStructureType)1000071003

  345. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES                  (VkStructureType)1000071004

  346. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO

  347. #define VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR           VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES

  348. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO

  349. #define VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR                 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES

  350. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR              VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES

  351. #define VK_LUID_SIZE                                                     8U

  352. #define VK_LUID_SIZE_KHR                                                 VK_LUID_SIZE

  353. typedef enum VkExternalMemoryHandleTypeFlagBits

  354. {

  355.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,

  356.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,

  357.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,

  358.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,

  359.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,

  360.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,

  361.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,

  362.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,

  363.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,

  364.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,

  365.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,

  366.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800,

  367.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000,

  368.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,

  369.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,

  370.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,

  371.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,

  372.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,

  373.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,

  374.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,

  375.     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

  376. } VkExternalMemoryHandleTypeFlagBits;

  377. typedef VkFlags VkExternalMemoryHandleTypeFlags;

  378. typedef enum VkExternalMemoryFeatureFlagBits

  379. {

  380.     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,

  381.     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,

  382.     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,

  383.     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,

  384.     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,

  385.     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,

  386.     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

  387. } VkExternalMemoryFeatureFlagBits;

  388. typedef VkFlags VkExternalMemoryFeatureFlags;

  389. typedef struct VkExternalMemoryProperties

  390. {

  391.     VkExternalMemoryFeatureFlags externalMemoryFeatures;

  392.     VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;

  393.     VkExternalMemoryHandleTypeFlags compatibleHandleTypes;

  394. } VkExternalMemoryProperties;

  395. typedef struct VkPhysicalDeviceExternalImageFormatInfo

  396. {

  397.     VkStructureType sType;

  398.     const void* pNext;

  399.     VkExternalMemoryHandleTypeFlagBits handleType;

  400. } VkPhysicalDeviceExternalImageFormatInfo;

  401. typedef struct VkExternalImageFormatProperties

  402. {

  403.     VkStructureType sType;

  404.     void* pNext;

  405.     VkExternalMemoryProperties externalMemoryProperties;

  406. } VkExternalImageFormatProperties;

  407. typedef struct VkPhysicalDeviceExternalBufferInfo

  408. {

  409.     VkStructureType sType;

  410.     const void* pNext;

  411.     VkBufferCreateFlags flags;

  412.     VkBufferUsageFlags usage;

  413.     VkExternalMemoryHandleTypeFlagBits handleType;

  414. } VkPhysicalDeviceExternalBufferInfo;

  415. typedef struct VkExternalBufferProperties

  416. {

  417.     VkStructureType sType;

  418.     void* pNext;

  419.     VkExternalMemoryProperties externalMemoryProperties;

  420. } VkExternalBufferProperties;

  421. typedef struct VkPhysicalDeviceIDProperties

  422. {

  423.     VkStructureType sType;

  424.     void* pNext;

  425.     uint8_t deviceUUID[VK_UUID_SIZE];

  426.     uint8_t driverUUID[VK_UUID_SIZE];

  427.     uint8_t deviceLUID[VK_LUID_SIZE];

  428.     uint32_t deviceNodeMask;

  429.     VkBool32 deviceLUIDValid;

  430. } VkPhysicalDeviceIDProperties;

  431. typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;

  432. typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;

  433. typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;

  434. typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;

  435. typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;

  436. typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;

  437. typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;

  438. typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;

  439. typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;

  440. typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;

  441. typedef void(VKAPI_PTR* PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);

  442. typedef PFN_vkGetPhysicalDeviceExternalBufferProperties PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR;

  443. #endif // VK_KHR_external_memory_capabilities

  444. 

  445. #ifndef VK_KHR_get_memory_requirements2

  446. #define VK_KHR_get_memory_requirements2                         1

  447. #define VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2     (VkStructureType)1000146000

  448. #define VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2      (VkStructureType)1000146001

  449. #define VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2                 (VkStructureType)1000146003

  450. #define VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2

  451. #define VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR  VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2

  452. #define VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR             VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2

  453. typedef struct VkBufferMemoryRequirementsInfo2

  454. {

  455.     VkStructureType sType;

  456.     const void* pNext;

  457.     VkBuffer buffer;

  458. } VkBufferMemoryRequirementsInfo2;

  459. typedef struct VkImageMemoryRequirementsInfo2

  460. {

  461.     VkStructureType sType;

  462.     const void* pNext;

  463.     VkImage image;

  464. } VkImageMemoryRequirementsInfo2;

  465. typedef struct VkMemoryRequirements2

  466. {

  467.     VkStructureType sType;

  468.     void* pNext;

  469.     VkMemoryRequirements memoryRequirements;

  470. } VkMemoryRequirements2;

  471. typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;

  472. typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;

  473. typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;

  474. typedef void(VKAPI_PTR* PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

  475. typedef void(VKAPI_PTR* PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

  476. typedef PFN_vkGetImageMemoryRequirements2 PFN_vkGetImageMemoryRequirements2KHR;

  477. typedef PFN_vkGetBufferMemoryRequirements2 PFN_vkGetBufferMemoryRequirements2KHR;

  478. #endif // VK_KHR_get_memory_requirements2

  479. 

  480. #ifndef VK_KHR_dedicated_allocation

  481. #define VK_KHR_dedicated_allocation                          1

  482. #define VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS      (VkStructureType)1000127000

  483. #define VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO     (VkStructureType)1000127001

  484. #define VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR  VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS

  485. #define VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO

  486. typedef struct VkMemoryDedicatedRequirements

  487. {

  488.     VkStructureType sType;

  489.     void* pNext;

  490.     VkBool32 prefersDedicatedAllocation;

  491.     VkBool32 requiresDedicatedAllocation;

  492. } VkMemoryDedicatedRequirements;

  493. typedef struct VkMemoryDedicatedAllocateInfo

  494. {

  495.     VkStructureType sType;

  496.     const void* pNext;

  497.     VkImage image;

  498.     VkBuffer buffer;

  499. } VkMemoryDedicatedAllocateInfo;

  500. typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;

  501. typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;

  502. #endif // VK_KHR_dedicated_allocation

  503. 

  504. #ifndef VK_KHR_16bit_storage

  505. #define VK_KHR_16bit_storage                                         1

  506. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES     (VkStructureType)1000083000

  507. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES

  508. typedef struct VkPhysicalDevice16BitStorageFeatures

  509. {

  510.     VkStructureType sType;

  511.     void* pNext;

  512.     VkBool32 storageBuffer16BitAccess;

  513.     VkBool32 uniformAndStorageBuffer16BitAccess;

  514.     VkBool32 storagePushConstant16;

  515.     VkBool32 storageInputOutput16;

  516. } VkPhysicalDevice16BitStorageFeatures;

  517. typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;

  518. #endif // VK_KHR_16bit_storage

  519. 

  520. #ifndef VK_KHR_bind_memory2

  521. #define VK_KHR_bind_memory2                           1

  522. #define VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO     (VkStructureType)1000157000

  523. #define VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO      (VkStructureType)1000157001

  524. #define VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO

  525. #define VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR  VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO

  526. typedef struct VkBindBufferMemoryInfo

  527. {

  528.     VkStructureType sType;

  529.     const void* pNext;

  530.     VkBuffer buffer;

  531.     VkDeviceMemory memory;

  532.     VkDeviceSize memoryOffset;

  533. } VkBindBufferMemoryInfo;

  534. typedef struct VkBindImageMemoryInfo

  535. {

  536.     VkStructureType sType;

  537.     const void* pNext;

  538.     VkImage image;

  539.     VkDeviceMemory memory;

  540.     VkDeviceSize memoryOffset;

  541. } VkBindImageMemoryInfo;

  542. typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;

  543. typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;

  544. typedef VkResult(VKAPI_PTR* PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);

  545. typedef VkResult(VKAPI_PTR* PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);

  546. typedef PFN_vkBindBufferMemory2 PFN_vkBindBufferMemory2KHR;

  547. typedef PFN_vkBindImageMemory2 PFN_vkBindImageMemory2KHR;

  548. #endif // VK_KHR_bind_memory2

  549. 

  550. #ifndef VK_KHR_sampler_ycbcr_conversion

  551. #define VK_KHR_sampler_ycbcr_conversion                                         1

  552. #define VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO                  (VkStructureType)1000156000

  553. #define VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO                         (VkStructureType)1000156001

  554. #define VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO                          (VkStructureType)1000156002

  555. #define VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO                  (VkStructureType)1000156003

  556. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES     (VkStructureType)1000156004

  557. #define VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES      (VkStructureType)1000156005

  558. #define VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR              VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO

  559. #define VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR                     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO

  560. #define VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR                      VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO

  561. #define VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR              VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO

  562. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES

  563. #define VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR  VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES

  564. VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)

  565. typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;

  566. typedef enum VkSamplerYcbcrModelConversion

  567. {

  568.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,

  569.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,

  570.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,

  571.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,

  572.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,

  573.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,

  574.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,

  575.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,

  576.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,

  577.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,

  578.     VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF

  579. } VkSamplerYcbcrModelConversion;

  580. typedef enum VkSamplerYcbcrRange

  581. {

  582.     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,

  583.     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,

  584.     VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,

  585.     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,

  586.     VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF

  587. } VkSamplerYcbcrRange;

  588. typedef enum VkChromaLocation

  589. {

  590.     VK_CHROMA_LOCATION_COSITED_EVEN = 0,

  591.     VK_CHROMA_LOCATION_MIDPOINT = 1,

  592.     VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,

  593.     VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,

  594.     VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF

  595. } VkChromaLocation;

  596. typedef struct VkSamplerYcbcrConversionCreateInfo

  597. {

  598.     VkStructureType sType;

  599.     const void* pNext;

  600.     VkFormat format;

  601.     VkSamplerYcbcrModelConversion ycbcrModel;

  602.     VkSamplerYcbcrRange ycbcrRange;

  603.     VkComponentMapping components;

  604.     VkChromaLocation xChromaOffset;

  605.     VkChromaLocation yChromaOffset;

  606.     VkFilter chromaFilter;

  607.     VkBool32 forceExplicitReconstruction;

  608. } VkSamplerYcbcrConversionCreateInfo;

  609. typedef struct VkSamplerYcbcrConversionInfo

  610. {

  611.     VkStructureType sType;

  612.     const void* pNext;

  613.     VkSamplerYcbcrConversion conversion;

  614. } VkSamplerYcbcrConversionInfo;

  615. typedef struct VkBindImagePlaneMemoryInfo

  616. {

  617.     VkStructureType sType;

  618.     const void* pNext;

  619.     VkImageAspectFlagBits planeAspect;

  620. } VkBindImagePlaneMemoryInfo;

  621. typedef struct VkImagePlaneMemoryRequirementsInfo

  622. {

  623.     VkStructureType sType;

  624.     const void* pNext;

  625.     VkImageAspectFlagBits planeAspect;

  626. } VkImagePlaneMemoryRequirementsInfo;

  627. typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures

  628. {

  629.     VkStructureType sType;

  630.     void* pNext;

  631.     VkBool32 samplerYcbcrConversion;

  632. } VkPhysicalDeviceSamplerYcbcrConversionFeatures;

  633. typedef struct VkSamplerYcbcrConversionImageFormatProperties

  634. {

  635.     VkStructureType sType;

  636.     void* pNext;

  637.     uint32_t combinedImageSamplerDescriptorCount;

  638. } VkSamplerYcbcrConversionImageFormatProperties;

  639. typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;

  640. typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;

  641. typedef VkChromaLocation VkChromaLocationKHR;

  642. typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;

  643. typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;

  644. typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;

  645. typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;

  646. typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;

  647. typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;

  648. typedef VkResult(VKAPI_PTR* PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);

  649. typedef void(VKAPI_PTR* PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);

  650. typedef PFN_vkCreateSamplerYcbcrConversion PFN_vkCreateSamplerYcbcrConversionKHR;

  651. typedef PFN_vkDestroySamplerYcbcrConversion PFN_vkDestroySamplerYcbcrConversionKHR;

  652. #endif // VK_KHR_sampler_ycbcr_conversion

  653. 

  654. #if VK_HEADER_VERSION < 70

  655. // the unpublished VK_KHR_subgroup

  656. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES (VkStructureType)1000094000

  657. typedef enum VkSubgroupFeatureFlagBits

  658. {

  659.     VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,

  660.     VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,

  661.     VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,

  662.     VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,

  663.     VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,

  664.     VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,

  665.     VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,

  666.     VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,

  667.     VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,

  668.     VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

  669. } VkSubgroupFeatureFlagBits;

  670. typedef VkFlags VkSubgroupFeatureFlags;

  671. typedef struct VkPhysicalDeviceSubgroupProperties

  672. {

  673.     VkStructureType sType;

  674.     void* pNext;

  675.     uint32_t subgroupSize;

  676.     VkShaderStageFlags supportedStages;

  677.     VkSubgroupFeatureFlags supportedOperations;

  678.     VkBool32 quadOperationsInAllStages;

  679. } VkPhysicalDeviceSubgroupProperties;

  680. 

  681. // the unpublished VK_KHR_protected_memory

  682. #define VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO                       (VkStructureType)1000145000

  683. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES   (VkStructureType)1000145001

  684. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES (VkStructureType)1000145002

  685. #define VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2                         (VkStructureType)1000145003

  686. #define VK_MEMORY_PROPERTY_PROTECTED_BIT                              (VkMemoryPropertyFlagBits)0x00000020

  687. #define VK_IMAGE_CREATE_PROTECTED_BIT                                 (VkImageCreateFlagBits)0x00000800

  688. #define VK_BUFFER_CREATE_PROTECTED_BIT                                (VkBufferCreateFlagBits)0x00000008

  689. #define VK_QUEUE_PROTECTED_BIT                                        (VkQueueFlagBits)0x00000010

  690. #define VK_COMMAND_POOL_CREATE_PROTECTED_BIT                          (VkCommandPoolCreateFlagBits)0x00000004

  691. typedef enum VkDeviceQueueCreateFlagBits

  692. {

  693.     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,

  694.     VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

  695. } VkDeviceQueueCreateFlagBits;

  696. typedef VkFlags VkDeviceQueueCreateFlags;

  697. typedef struct VkPhysicalDeviceProtectedMemoryFeatures

  698. {

  699.     VkStructureType sType;

  700.     void* pNext;

  701.     VkBool32 protectedMemory;

  702. } VkPhysicalDeviceProtectedMemoryFeatures;

  703. typedef struct VkPhysicalDeviceProtectedMemoryProperties

  704. {

  705.     VkStructureType sType;

  706.     void* pNext;

  707.     VkBool32 protectedNoFault;

  708. } VkPhysicalDeviceProtectedMemoryProperties;

  709. typedef struct VkProtectedSubmitInfo

  710. {

  711.     VkStructureType sType;

  712.     const void* pNext;

  713.     VkBool32 protectedSubmit;

  714. } VkProtectedSubmitInfo;

  715. #endif // VK_HEADER_VERSION < 70

  716. 

  717. #if VK_HEADER_VERSION < 204

  718. typedef uint64_t VkFlags64;

  719. #endif // VK_HEADER_VERSION < 204

  720. 

  721. #ifndef VK_KHR_format_feature_flags2

  722. #define VK_KHR_format_feature_flags2              1

  723. #define VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3     (VkStructureType)1000360000

  724. #define VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3

  725. typedef VkFlags64 VkFormatFeatureFlags2;

  726. typedef VkFlags64 VkFormatFeatureFlagBits2;

  727. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0x00000001ULL;

  728. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL;

  729. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0x00000002ULL;

  730. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL;

  731. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004ULL;

  732. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL;

  733. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008ULL;

  734. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL;

  735. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000010ULL;

  736. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL;

  737. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020ULL;

  738. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL;

  739. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0x00000040ULL;

  740. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL;

  741. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0x00000080ULL;

  742. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL;

  743. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100ULL;

  744. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL;

  745. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200ULL;

  746. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL;

  747. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0x00000400ULL;

  748. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL;

  749. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0x00000800ULL;

  750. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL;

  751. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000ULL;

  752. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL;

  753. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0x00002000ULL;

  754. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL;

  755. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0x00004000ULL;

  756. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL;

  757. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0x00008000ULL;

  758. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL;

  759. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000ULL;

  760. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL;

  761. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000ULL;

  762. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL;

  763. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000ULL;

  764. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL;

  765. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000ULL;

  766. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL;

  767. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000ULL;

  768. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL;

  769. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000ULL;

  770. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL;

  771. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0x00400000ULL;

  772. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL;

  773. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0x00800000ULL;

  774. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL;

  775. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0x80000000ULL;

  776. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL;

  777. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0x100000000ULL;

  778. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL;

  779. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0x200000000ULL;

  780. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL;

  781. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL;

  782. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL;

  783. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL;

  784. static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL;

  785. typedef struct VkFormatProperties3

  786. {

  787.     VkStructureType sType;

  788.     void* pNext;

  789.     VkFormatFeatureFlags2 linearTilingFeatures;

  790.     VkFormatFeatureFlags2 optimalTilingFeatures;

  791.     VkFormatFeatureFlags2 bufferFeatures;

  792. } VkFormatProperties3;

  793. typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR;

  794. typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR;

  795. typedef VkFormatProperties3 VkFormatProperties3KHR;

  796. #endif // VK_KHR_format_feature_flags2

  797. 

  798. #ifndef VK_ANDROID_external_memory_android_hardware_buffer

  799. #define VK_ANDROID_external_memory_android_hardware_buffer                    1

  800. #define VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID               (VkStructureType)1000129000

  801. #define VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID          (VkStructureType)1000129001

  802. #define VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID   (VkStructureType)1000129002

  803. #define VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID         (VkStructureType)1000129003

  804. #define VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID     (VkStructureType)1000129004

  805. #define VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID                             (VkStructureType)1000129005

  806. #define VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID (VkStructureType)1000129006

  807. struct AHardwareBuffer;

  808. typedef struct VkAndroidHardwareBufferUsageANDROID

  809. {

  810.     VkStructureType sType;

  811.     void* pNext;

  812.     uint64_t androidHardwareBufferUsage;

  813. } VkAndroidHardwareBufferUsageANDROID;

  814. typedef struct VkAndroidHardwareBufferPropertiesANDROID

  815. {

  816.     VkStructureType sType;

  817.     void* pNext;

  818.     VkDeviceSize allocationSize;

  819.     uint32_t memoryTypeBits;

  820. } VkAndroidHardwareBufferPropertiesANDROID;

  821. typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID

  822. {

  823.     VkStructureType sType;

  824.     void* pNext;

  825.     VkFormat format;

  826.     uint64_t externalFormat;

  827.     VkFormatFeatureFlags formatFeatures;

  828.     VkComponentMapping samplerYcbcrConversionComponents;

  829.     VkSamplerYcbcrModelConversion suggestedYcbcrModel;

  830.     VkSamplerYcbcrRange suggestedYcbcrRange;

  831.     VkChromaLocation suggestedXChromaOffset;

  832.     VkChromaLocation suggestedYChromaOffset;

  833. } VkAndroidHardwareBufferFormatPropertiesANDROID;

  834. typedef struct VkImportAndroidHardwareBufferInfoANDROID

  835. {

  836.     VkStructureType sType;

  837.     const void* pNext;

  838.     struct AHardwareBuffer* buffer;

  839. } VkImportAndroidHardwareBufferInfoANDROID;

  840. typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID

  841. {

  842.     VkStructureType sType;

  843.     const void* pNext;

  844.     VkDeviceMemory memory;

  845. } VkMemoryGetAndroidHardwareBufferInfoANDROID;

  846. typedef struct VkExternalFormatANDROID

  847. {

  848.     VkStructureType sType;

  849.     void* pNext;

  850.     uint64_t externalFormat;

  851. } VkExternalFormatANDROID;

  852. typedef struct VkAndroidHardwareBufferFormatProperties2ANDROID

  853. {

  854.     VkStructureType sType;

  855.     void* pNext;

  856.     VkFormat format;

  857.     uint64_t externalFormat;

  858.     VkFormatFeatureFlags2 formatFeatures;

  859.     VkComponentMapping samplerYcbcrConversionComponents;

  860.     VkSamplerYcbcrModelConversion suggestedYcbcrModel;

  861.     VkSamplerYcbcrRange suggestedYcbcrRange;

  862.     VkChromaLocation suggestedXChromaOffset;

  863.     VkChromaLocation suggestedYChromaOffset;

  864. } VkAndroidHardwareBufferFormatProperties2ANDROID;

  865. typedef VkResult(VKAPI_PTR* PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);

  866. typedef VkResult(VKAPI_PTR* PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);

  867. #endif // VK_ANDROID_external_memory_android_hardware_buffer

  868. 

  869. #ifndef VK_KHR_maintenance3

  870. #define VK_KHR_maintenance3                                        1

  871. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES (VkStructureType)1000168000

  872. #define VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT            (VkStructureType)1000168001

  873. typedef struct VkPhysicalDeviceMaintenance3Properties

  874. {

  875.     VkStructureType sType;

  876.     void* pNext;

  877.     uint32_t maxPerSetDescriptors;

  878.     VkDeviceSize maxMemoryAllocationSize;

  879. } VkPhysicalDeviceMaintenance3Properties;

  880. typedef struct VkDescriptorSetLayoutSupport

  881. {

  882.     VkStructureType sType;

  883.     void* pNext;

  884.     VkBool32 supported;

  885. } VkDescriptorSetLayoutSupport;

  886. typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;

  887. typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;

  888. typedef void(VKAPI_PTR* PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);

  889. typedef PFN_vkGetDescriptorSetLayoutSupport PFN_vkGetDescriptorSetLayoutSupportKHR;

  890. #endif // VK_KHR_maintenance3

  891. 

  892. #ifndef VK_KHR_8bit_storage

  893. #define VK_KHR_8bit_storage                                         1

  894. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES     (VkStructureType)1000177000

  895. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES

  896. typedef struct VkPhysicalDevice8BitStorageFeatures

  897. {

  898.     VkStructureType sType;

  899.     void* pNext;

  900.     VkBool32 storageBuffer8BitAccess;

  901.     VkBool32 uniformAndStorageBuffer8BitAccess;

  902.     VkBool32 storagePushConstant8;

  903. } VkPhysicalDevice8BitStorageFeatures;

  904. typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR;

  905. #endif // VK_KHR_8bit_storage

  906. 

  907. #ifndef VK_KHR_shader_float16_int8

  908. #define VK_KHR_shader_float16_int8                                  1

  909. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES     (VkStructureType)1000082000

  910. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES

  911. typedef struct VkPhysicalDeviceFloat16Int8FeaturesKHR

  912. {

  913.     VkStructureType sType;

  914.     void* pNext;

  915.     VkBool32 shaderFloat16;

  916.     VkBool32 shaderInt8;

  917. } VkPhysicalDeviceFloat16Int8FeaturesKHR;

  918. #endif // VK_KHR_shader_float16_int8

  919. 

  920. #ifndef VK_EXT_memory_budget

  921. #define VK_EXT_memory_budget                                           1

  922. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT (VkStructureType)1000237000

  923. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT (VkStructureType)1000238000

  924. #define VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT            (VkStructureType)1000238001

  925. typedef uint64_t VkDeviceAddress;

  926. typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT

  927. {

  928.     VkStructureType sType;

  929.     void* pNext;

  930.     VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];

  931.     VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];

  932. } VkPhysicalDeviceMemoryBudgetPropertiesEXT;

  933. typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT

  934. {

  935.     VkStructureType sType;

  936.     void* pNext;

  937.     VkBool32 memoryPriority;

  938. } VkPhysicalDeviceMemoryPriorityFeaturesEXT;

  939. typedef struct VkMemoryPriorityAllocateInfoEXT

  940. {

  941.     VkStructureType sType;

  942.     const void* pNext;

  943.     float priority;

  944. } VkMemoryPriorityAllocateInfoEXT;

  945. #endif // VK_EXT_memory_budget

  946. 

  947. #ifndef VK_EXT_buffer_device_address

  948. #define VK_EXT_buffer_device_address                                  1

  949. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT (VkStructureType)1000244000

  950. #define VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT              (VkStructureType)1000244001

  951. #define VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT       (VkStructureType)1000244002

  952. #define VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT                 (VkBufferUsageFlagBits)0x00020000

  953. typedef struct VkPhysicalDeviceBufferAddressFeaturesEXT

  954. {

  955.     VkStructureType sType;

  956.     void* pNext;

  957.     VkBool32 bufferDeviceAddress;

  958.     VkBool32 bufferDeviceAddressCaptureReplay;

  959.     VkBool32 bufferDeviceAddressMultiDevice;

  960. } VkPhysicalDeviceBufferAddressFeaturesEXT;

  961. typedef struct VkBufferDeviceAddressInfoEXT

  962. {

  963.     VkStructureType sType;

  964.     const void* pNext;

  965.     VkBuffer buffer;

  966. } VkBufferDeviceAddressInfoEXT;

  967. typedef struct VkBufferDeviceAddressCreateInfoEXT

  968. {

  969.     VkStructureType sType;

  970.     const void* pNext;

  971.     VkDeviceSize deviceAddress;

  972. } VkBufferDeviceAddressCreateInfoEXT;

  973. typedef VkDeviceAddress(VKAPI_PTR* PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo);

  974. #endif // VK_EXT_buffer_device_address

  975. 

  976. #ifndef VK_EXT_validation_features

  977. #define VK_EXT_validation_features                             1

  978. #define VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT              (VkStructureType)1000247000

  979. #define VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT (VkBufferCreateFlagBits)0x00020000

  980. typedef enum VkValidationFeatureEnableEXT

  981. {

  982.     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,

  983.     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,

  984.     VK_VALIDATION_FEATURE_ENABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,

  985.     VK_VALIDATION_FEATURE_ENABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT,

  986.     VK_VALIDATION_FEATURE_ENABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT + 1),

  987.     VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF

  988. } VkValidationFeatureEnableEXT;

  989. typedef enum VkValidationFeatureDisableEXT

  990. {

  991.     VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,

  992.     VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,

  993.     VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,

  994.     VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,

  995.     VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,

  996.     VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,

  997.     VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,

  998.     VK_VALIDATION_FEATURE_DISABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT,

  999.     VK_VALIDATION_FEATURE_DISABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT,

  1000.     VK_VALIDATION_FEATURE_DISABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT - VK_VALIDATION_FEATURE_DISABLE_ALL_EXT + 1),

  1001.     VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF

  1002. } VkValidationFeatureDisableEXT;

  1003. typedef struct VkValidationFeaturesEXT

  1004. {

  1005.     VkStructureType sType;

  1006.     const void* pNext;

  1007.     uint32_t enabledValidationFeatureCount;

  1008.     const VkValidationFeatureEnableEXT* pEnabledValidationFeatures;

  1009.     uint32_t disabledValidationFeatureCount;

  1010.     const VkValidationFeatureDisableEXT* pDisabledValidationFeatures;

  1011. } VkValidationFeaturesEXT;

  1012. #endif // VK_EXT_validation_features

  1013. 

  1014. #ifndef VK_NV_cooperative_matrix

  1015. #define VK_NV_cooperative_matrix                                           1

  1016. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV   (VkStructureType)1000249000

  1017. #define VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV                 (VkStructureType)1000249001

  1018. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV (VkStructureType)1000249002

  1019. typedef enum VkComponentTypeNV

  1020. {

  1021.     VK_COMPONENT_TYPE_FLOAT16_NV = 0,

  1022.     VK_COMPONENT_TYPE_FLOAT32_NV = 1,

  1023.     VK_COMPONENT_TYPE_FLOAT64_NV = 2,

  1024.     VK_COMPONENT_TYPE_SINT8_NV = 3,

  1025.     VK_COMPONENT_TYPE_SINT16_NV = 4,

  1026.     VK_COMPONENT_TYPE_SINT32_NV = 5,

  1027.     VK_COMPONENT_TYPE_SINT64_NV = 6,

  1028.     VK_COMPONENT_TYPE_UINT8_NV = 7,

  1029.     VK_COMPONENT_TYPE_UINT16_NV = 8,

  1030.     VK_COMPONENT_TYPE_UINT32_NV = 9,

  1031.     VK_COMPONENT_TYPE_UINT64_NV = 10,

  1032.     VK_COMPONENT_TYPE_BEGIN_RANGE_NV = VK_COMPONENT_TYPE_FLOAT16_NV,

  1033.     VK_COMPONENT_TYPE_END_RANGE_NV = VK_COMPONENT_TYPE_UINT64_NV,

  1034.     VK_COMPONENT_TYPE_RANGE_SIZE_NV = (VK_COMPONENT_TYPE_UINT64_NV - VK_COMPONENT_TYPE_FLOAT16_NV + 1),

  1035.     VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF

  1036. } VkComponentTypeNV;

  1037. typedef enum VkScopeNV

  1038. {

  1039.     VK_SCOPE_DEVICE_NV = 1,

  1040.     VK_SCOPE_WORKGROUP_NV = 2,

  1041.     VK_SCOPE_SUBGROUP_NV = 3,

  1042.     VK_SCOPE_QUEUE_FAMILY_NV = 5,

  1043.     VK_SCOPE_BEGIN_RANGE_NV = VK_SCOPE_DEVICE_NV,

  1044.     VK_SCOPE_END_RANGE_NV = VK_SCOPE_QUEUE_FAMILY_NV,

  1045.     VK_SCOPE_RANGE_SIZE_NV = (VK_SCOPE_QUEUE_FAMILY_NV - VK_SCOPE_DEVICE_NV + 1),

  1046.     VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF

  1047. } VkScopeNV;

  1048. typedef struct VkCooperativeMatrixPropertiesNV

  1049. {

  1050.     VkStructureType sType;

  1051.     void* pNext;

  1052.     uint32_t MSize;

  1053.     uint32_t NSize;

  1054.     uint32_t KSize;

  1055.     VkComponentTypeNV AType;

  1056.     VkComponentTypeNV BType;

  1057.     VkComponentTypeNV CType;

  1058.     VkComponentTypeNV DType;

  1059.     VkScopeNV scope;

  1060. } VkCooperativeMatrixPropertiesNV;

  1061. typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV

  1062. {

  1063.     VkStructureType sType;

  1064.     void* pNext;

  1065.     VkBool32 cooperativeMatrix;

  1066.     VkBool32 cooperativeMatrixRobustBufferAccess;

  1067. } VkPhysicalDeviceCooperativeMatrixFeaturesNV;

  1068. typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV

  1069. {

  1070.     VkStructureType sType;

  1071.     void* pNext;

  1072.     VkShaderStageFlags cooperativeMatrixSupportedStages;

  1073. } VkPhysicalDeviceCooperativeMatrixPropertiesNV;

  1074. typedef VkResult(VKAPI_PTR* PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties);

  1075. #endif // VK_NV_cooperative_matrix

  1076. 

  1077. #ifndef VK_AMD_device_coherent_memory

  1078. #define VK_AMD_device_coherent_memory                                  1

  1079. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD (VkStructureType)1000229000

  1080. #define VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD                     (VkMemoryPropertyFlagBits)0x00000040

  1081. #define VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD                     (VkMemoryPropertyFlagBits)0x00000040

  1082. typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD

  1083. {

  1084.     VkStructureType sType;

  1085.     void* pNext;

  1086.     VkBool32 deviceCoherentMemory;

  1087. } VkPhysicalDeviceCoherentMemoryFeaturesAMD;

  1088. #endif // VK_AMD_device_coherent_memory

  1089. 

  1090. #ifndef VK_KHR_buffer_device_address

  1091. #define VK_KHR_buffer_device_address                                         1

  1092. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES     (VkStructureType)1000257000

  1093. #define VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO                         (VkStructureType)1000244001

  1094. #define VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO          (VkStructureType)1000257002

  1095. #define VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO        (VkStructureType)1000257003

  1096. #define VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO          (VkStructureType)1000257004

  1097. #define VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT                   (VkBufferCreateFlagBits)0x00020000

  1098. #define VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT                            (VkBufferUsageFlagBits)0x00020000

  1099. #define VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT                                (VkMemoryAllocateFlagBits)0x00000002

  1100. #define VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT                 (VkMemoryAllocateFlagBits)0x00000004

  1101. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES

  1102. #define VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR                     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO

  1103. #define VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR      VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO

  1104. #define VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR    VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO

  1105. #define VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR      VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO

  1106. #define VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR               VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT

  1107. #define VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR                        VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT

  1108. #define VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR                            VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT

  1109. #define VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR             VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT

  1110. typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures

  1111. {

  1112.     VkStructureType sType;

  1113.     void* pNext;

  1114.     VkBool32 bufferDeviceAddress;

  1115.     VkBool32 bufferDeviceAddressCaptureReplay;

  1116.     VkBool32 bufferDeviceAddressMultiDevice;

  1117. } VkPhysicalDeviceBufferDeviceAddressFeatures;

  1118. typedef struct VkBufferDeviceAddressInfo

  1119. {

  1120.     VkStructureType sType;

  1121.     const void* pNext;

  1122.     VkBuffer buffer;

  1123. } VkBufferDeviceAddressInfo;

  1124. typedef struct VkBufferOpaqueCaptureAddressCreateInfo

  1125. {

  1126.     VkStructureType sType;

  1127.     const void* pNext;

  1128.     uint64_t opaqueCaptureAddress;

  1129. } VkBufferOpaqueCaptureAddressCreateInfo;

  1130. typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo

  1131. {

  1132.     VkStructureType sType;

  1133.     const void* pNext;

  1134.     uint64_t opaqueCaptureAddress;

  1135. } VkMemoryOpaqueCaptureAddressAllocateInfo;

  1136. typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo

  1137. {

  1138.     VkStructureType sType;

  1139.     const void* pNext;

  1140.     VkDeviceMemory memory;

  1141. } VkDeviceMemoryOpaqueCaptureAddressInfo;

  1142. typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;

  1143. typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR;

  1144. typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR;

  1145. typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR;

  1146. typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR;

  1147. typedef VkDeviceAddress(VKAPI_PTR* PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);

  1148. typedef uint64_t(VKAPI_PTR* PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);

  1149. typedef uint64_t(VKAPI_PTR* PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);

  1150. typedef PFN_vkGetBufferDeviceAddress PFN_vkGetBufferDeviceAddressKHR;

  1151. typedef PFN_vkGetBufferOpaqueCaptureAddress PFN_vkGetBufferOpaqueCaptureAddressKHR;

  1152. typedef PFN_vkGetDeviceMemoryOpaqueCaptureAddress PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR;

  1153. #endif // VK_KHR_buffer_device_address

  1154. 

  1155. #ifndef VK_KHR_portability_enumeration

  1156. #define VK_KHR_portability_enumeration 1

  1157. typedef enum VkInstanceCreateFlagBits

  1158. {

  1159.     VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 0x00000001,

  1160.     VK_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

  1161. } VkInstanceCreateFlagBits;

  1162. #endif // VK_KHR_portability_enumeration

  1163. 

  1164. #ifndef VK_KHR_cooperative_matrix

  1165. #define VK_KHR_cooperative_matrix                                           1

  1166. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR   (VkStructureType)1000506000

  1167. #define VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR                 (VkStructureType)1000506001

  1168. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR (VkStructureType)1000506002

  1169. typedef enum VkComponentTypeKHR

  1170. {

  1171.     VK_COMPONENT_TYPE_FLOAT16_KHR = 0,

  1172.     VK_COMPONENT_TYPE_FLOAT32_KHR = 1,

  1173.     VK_COMPONENT_TYPE_FLOAT64_KHR = 2,

  1174.     VK_COMPONENT_TYPE_SINT8_KHR = 3,

  1175.     VK_COMPONENT_TYPE_SINT16_KHR = 4,

  1176.     VK_COMPONENT_TYPE_SINT32_KHR = 5,

  1177.     VK_COMPONENT_TYPE_SINT64_KHR = 6,

  1178.     VK_COMPONENT_TYPE_UINT8_KHR = 7,

  1179.     VK_COMPONENT_TYPE_UINT16_KHR = 8,

  1180.     VK_COMPONENT_TYPE_UINT32_KHR = 9,

  1181.     VK_COMPONENT_TYPE_UINT64_KHR = 10,

  1182.     VK_COMPONENT_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF

  1183. } VkComponentTypeKHR;

  1184. typedef enum VkScopeKHR

  1185. {

  1186.     VK_SCOPE_DEVICE_KHR = 1,

  1187.     VK_SCOPE_WORKGROUP_KHR = 2,

  1188.     VK_SCOPE_SUBGROUP_KHR = 3,

  1189.     VK_SCOPE_QUEUE_FAMILY_KHR = 5,

  1190.     VK_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF

  1191. } VkScopeKHR;

  1192. typedef struct VkCooperativeMatrixPropertiesKHR

  1193. {

  1194.     VkStructureType sType;

  1195.     void* pNext;

  1196.     uint32_t MSize;

  1197.     uint32_t NSize;

  1198.     uint32_t KSize;

  1199.     VkComponentTypeKHR AType;

  1200.     VkComponentTypeKHR BType;

  1201.     VkComponentTypeKHR CType;

  1202.     VkComponentTypeKHR ResultType;

  1203.     VkBool32 saturatingAccumulation;

  1204.     VkScopeKHR scope;

  1205. } VkCooperativeMatrixPropertiesKHR;

  1206. typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR

  1207. {

  1208.     VkStructureType sType;

  1209.     void* pNext;

  1210.     VkBool32 cooperativeMatrix;

  1211.     VkBool32 cooperativeMatrixRobustBufferAccess;

  1212. } VkPhysicalDeviceCooperativeMatrixFeaturesKHR;

  1213. typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR

  1214. {

  1215.     VkStructureType sType;

  1216.     void* pNext;

  1217.     VkShaderStageFlags cooperativeMatrixSupportedStages;

  1218. } VkPhysicalDeviceCooperativeMatrixPropertiesKHR;

  1219. typedef VkResult(VKAPI_PTR* PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties);

  1220. #endif // VK_KHR_cooperative_matrix

  1221. 

  1222. #ifndef VK_KHR_driver_properties

  1223. #define VK_KHR_driver_properties                                1

  1224. #define VK_MAX_DRIVER_NAME_SIZE                                 256U

  1225. #define VK_MAX_DRIVER_INFO_SIZE                                 256U

  1226. #define VK_MAX_DRIVER_NAME_SIZE_KHR                             VK_MAX_DRIVER_NAME_SIZE

  1227. #define VK_MAX_DRIVER_INFO_SIZE_KHR                             VK_MAX_DRIVER_INFO_SIZE

  1228. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES     (VkStructureType)1000196000

  1229. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES

  1230. typedef enum VkDriverId

  1231. {

  1232.     VK_DRIVER_ID_AMD_PROPRIETARY = 1,

  1233.     VK_DRIVER_ID_AMD_OPEN_SOURCE = 2,

  1234.     VK_DRIVER_ID_MESA_RADV = 3,

  1235.     VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4,

  1236.     VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5,

  1237.     VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6,

  1238.     VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7,

  1239.     VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8,

  1240.     VK_DRIVER_ID_ARM_PROPRIETARY = 9,

  1241.     VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10,

  1242.     VK_DRIVER_ID_GGP_PROPRIETARY = 11,

  1243.     VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12,

  1244.     VK_DRIVER_ID_MESA_LLVMPIPE = 13,

  1245.     VK_DRIVER_ID_MOLTENVK = 14,

  1246.     VK_DRIVER_ID_COREAVI_PROPRIETARY = 15,

  1247.     VK_DRIVER_ID_JUICE_PROPRIETARY = 16,

  1248.     VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17,

  1249.     VK_DRIVER_ID_MESA_TURNIP = 18,

  1250.     VK_DRIVER_ID_MESA_V3DV = 19,

  1251.     VK_DRIVER_ID_MESA_PANVK = 20,

  1252.     VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21,

  1253.     VK_DRIVER_ID_MESA_VENUS = 22,

  1254.     VK_DRIVER_ID_MESA_DOZEN = 23,

  1255.     VK_DRIVER_ID_MESA_NVK = 24,

  1256.     VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25,

  1257.     VK_DRIVER_ID_MESA_AGXV = 26,

  1258.     VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF

  1259. } VkDriverId;

  1260. typedef struct VkConformanceVersion

  1261. {

  1262.     uint8_t major;

  1263.     uint8_t minor;

  1264.     uint8_t subminor;

  1265.     uint8_t patch;

  1266. } VkConformanceVersion;

  1267. typedef struct VkPhysicalDeviceDriverProperties

  1268. {

  1269.     VkStructureType sType;

  1270.     void* pNext;

  1271.     VkDriverId driverID;

  1272.     char driverName[VK_MAX_DRIVER_NAME_SIZE];

  1273.     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];

  1274.     VkConformanceVersion conformanceVersion;

  1275. } VkPhysicalDeviceDriverProperties;

  1276. typedef VkDriverId VkDriverIdKHR;

  1277. typedef VkConformanceVersion VkConformanceVersionKHR;

  1278. typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR;

  1279. #endif // VK_KHR_driver_properties

  1280. 

  1281. #ifndef VK_EXT_subgroup_size_control

  1282. #define VK_EXT_subgroup_size_control                                                   1

  1283. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES               (VkStructureType)1000225002

  1284. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES             (VkStructureType)1000225000

  1285. #define VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO     (VkStructureType)1000225001

  1286. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT           VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES

  1287. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES

  1288. #define VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO

  1289. typedef enum VkPipelineShaderStageCreateFlagBits

  1290. {

  1291.     VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0x00000001,

  1292.     VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0x00000002,

  1293.     VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT,

  1294.     VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT,

  1295.     VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

  1296. } VkPipelineShaderStageCreateFlagBits;

  1297. typedef VkFlags VkPipelineShaderStageCreateFlags;

  1298. typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures

  1299. {

  1300.     VkStructureType sType;

  1301.     void* pNext;

  1302.     VkBool32 subgroupSizeControl;

  1303.     VkBool32 computeFullSubgroups;

  1304. } VkPhysicalDeviceSubgroupSizeControlFeatures;

  1305. typedef struct VkPhysicalDeviceSubgroupSizeControlProperties

  1306. {

  1307.     VkStructureType sType;

  1308.     void* pNext;

  1309.     uint32_t minSubgroupSize;

  1310.     uint32_t maxSubgroupSize;

  1311.     uint32_t maxComputeWorkgroupSubgroups;

  1312.     VkShaderStageFlags requiredSubgroupSizeStages;

  1313. } VkPhysicalDeviceSubgroupSizeControlProperties;

  1314. typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo

  1315. {

  1316.     VkStructureType sType;

  1317.     void* pNext;

  1318.     uint32_t requiredSubgroupSize;

  1319. } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;

  1320. typedef VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;

  1321. typedef VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;

  1322. typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;

  1323. #endif // VK_EXT_subgroup_size_control

  1324. 

  1325. #ifndef VK_KHR_shader_subgroup_rotate

  1326. #define VK_KHR_shader_subgroup_rotate                                         1

  1327. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES     (VkStructureType)1000416000

  1328. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES

  1329. #define VK_SUBGROUP_FEATURE_ROTATE_BIT                                        (VkSubgroupFeatureFlagBits)0x00000200

  1330. #define VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT                              (VkSubgroupFeatureFlagBits)0x00000400

  1331. #define VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR                                    VK_SUBGROUP_FEATURE_ROTATE_BIT

  1332. #define VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR                          VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT

  1333. typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures

  1334. {

  1335.     VkStructureType sType;

  1336.     void* pNext;

  1337.     VkBool32 shaderSubgroupRotate;

  1338.     VkBool32 shaderSubgroupRotateClustered;

  1339. } VkPhysicalDeviceShaderSubgroupRotateFeatures;

  1340. typedef VkPhysicalDeviceShaderSubgroupRotateFeatures VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR;

  1341. #endif // VK_KHR_shader_subgroup_rotate

  1342. 

  1343. #ifndef VK_EXT_shader_atomic_float

  1344. #define VK_EXT_shader_atomic_float                                         1

  1345. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT (VkStructureType)1000260000

  1346. typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT

  1347. {

  1348.     VkStructureType sType;

  1349.     void* pNext;

  1350.     VkBool32 shaderBufferFloat32Atomics;

  1351.     VkBool32 shaderBufferFloat32AtomicAdd;

  1352.     VkBool32 shaderBufferFloat64Atomics;

  1353.     VkBool32 shaderBufferFloat64AtomicAdd;

  1354.     VkBool32 shaderSharedFloat32Atomics;

  1355.     VkBool32 shaderSharedFloat32AtomicAdd;

  1356.     VkBool32 shaderSharedFloat64Atomics;

  1357.     VkBool32 shaderSharedFloat64AtomicAdd;

  1358.     VkBool32 shaderImageFloat32Atomics;

  1359.     VkBool32 shaderImageFloat32AtomicAdd;

  1360.     VkBool32 sparseImageFloat32Atomics;

  1361.     VkBool32 sparseImageFloat32AtomicAdd;

  1362. } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;

  1363. #endif // VK_EXT_shader_atomic_float

  1364. 

  1365. #ifndef VK_EXT_shader_atomic_float2

  1366. #define VK_EXT_shader_atomic_float2                                          1

  1367. #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT (VkStructureType)1000273000

  1368. typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT

  1369. {

  1370.     VkStructureType sType;

  1371.     void* pNext;

  1372.     VkBool32 shaderBufferFloat16Atomics;

  1373.     VkBool32 shaderBufferFloat16AtomicAdd;

  1374.     VkBool32 shaderBufferFloat16AtomicMinMax;

  1375.     VkBool32 shaderBufferFloat32AtomicMinMax;

  1376.     VkBool32 shaderBufferFloat64AtomicMinMax;

  1377.     VkBool32 shaderSharedFloat16Atomics;

  1378.     VkBool32 shaderSharedFloat16AtomicAdd;

  1379.     VkBool32 shaderSharedFloat16AtomicMinMax;

  1380.     VkBool32 shaderSharedFloat32AtomicMinMax;

  1381.     VkBool32 shaderSharedFloat64AtomicMinMax;

  1382.     VkBool32 shaderImageFloat32AtomicMinMax;

  1383.     VkBool32 sparseImageFloat32AtomicMinMax;

  1384. } VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;

  1385. #endif // VK_EXT_shader_atomic_float2

  1386. 

  1387. #endif // NCNN_VULKAN_HEADER_FIX_H