external/vulkancts/framework/vulkan/vkNullDriverImpl.inl

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  * This file was generated by /scripts/gen_framework.py
   4  */
   5 VKAPI_ATTR VkResult VKAPI_CALL createInstance (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
   6 {
   7         DE_UNREF(pAllocator);
   8         VK_NULL_RETURN((*pInstance = allocateHandle<Instance, VkInstance>(pCreateInfo, pAllocator)));
   9 }
  10
  11 VKAPI_ATTR VkResult VKAPI_CALL createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
  12 {
  13         DE_UNREF(pAllocator);
  14         VK_NULL_RETURN((*pDevice = allocateHandle<Device, VkDevice>(physicalDevice, pCreateInfo, pAllocator)));
  15 }
  16
  17 VKAPI_ATTR VkResult VKAPI_CALL createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
  18 {
  19         DE_UNREF(pAllocator);
  20         VK_NULL_RETURN((*pFence = allocateNonDispHandle<Fence, VkFence>(device, pCreateInfo, pAllocator)));
  21 }
  22
  23 VKAPI_ATTR VkResult VKAPI_CALL createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
  24 {
  25         DE_UNREF(pAllocator);
  26         VK_NULL_RETURN((*pSemaphore = allocateNonDispHandle<Semaphore, VkSemaphore>(device, pCreateInfo, pAllocator)));
  27 }
  28
  29 VKAPI_ATTR VkResult VKAPI_CALL createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
  30 {
  31         DE_UNREF(pAllocator);
  32         VK_NULL_RETURN((*pEvent = allocateNonDispHandle<Event, VkEvent>(device, pCreateInfo, pAllocator)));
  33 }
  34
  35 VKAPI_ATTR VkResult VKAPI_CALL createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
  36 {
  37         DE_UNREF(pAllocator);
  38         VK_NULL_RETURN((*pQueryPool = allocateNonDispHandle<QueryPool, VkQueryPool>(device, pCreateInfo, pAllocator)));
  39 }
  40
  41 VKAPI_ATTR VkResult VKAPI_CALL createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
  42 {
  43         DE_UNREF(pAllocator);
  44         VK_NULL_RETURN((*pBuffer = allocateNonDispHandle<Buffer, VkBuffer>(device, pCreateInfo, pAllocator)));
  45 }
  46
  47 VKAPI_ATTR VkResult VKAPI_CALL createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
  48 {
  49         DE_UNREF(pAllocator);
  50         VK_NULL_RETURN((*pView = allocateNonDispHandle<BufferView, VkBufferView>(device, pCreateInfo, pAllocator)));
  51 }
  52
  53 VKAPI_ATTR VkResult VKAPI_CALL createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
  54 {
  55         DE_UNREF(pAllocator);
  56         VK_NULL_RETURN((*pImage = allocateNonDispHandle<Image, VkImage>(device, pCreateInfo, pAllocator)));
  57 }
  58
  59 VKAPI_ATTR VkResult VKAPI_CALL createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
  60 {
  61         DE_UNREF(pAllocator);
  62         VK_NULL_RETURN((*pView = allocateNonDispHandle<ImageView, VkImageView>(device, pCreateInfo, pAllocator)));
  63 }
  64
  65 VKAPI_ATTR VkResult VKAPI_CALL createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
  66 {
  67         DE_UNREF(pAllocator);
  68         VK_NULL_RETURN((*pShaderModule = allocateNonDispHandle<ShaderModule, VkShaderModule>(device, pCreateInfo, pAllocator)));
  69 }
  70
  71 VKAPI_ATTR VkResult VKAPI_CALL createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
  72 {
  73         DE_UNREF(pAllocator);
  74         VK_NULL_RETURN((*pPipelineCache = allocateNonDispHandle<PipelineCache, VkPipelineCache>(device, pCreateInfo, pAllocator)));
  75 }
  76
  77 VKAPI_ATTR VkResult VKAPI_CALL createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
  78 {
  79         DE_UNREF(pAllocator);
  80         VK_NULL_RETURN((*pPipelineLayout = allocateNonDispHandle<PipelineLayout, VkPipelineLayout>(device, pCreateInfo, pAllocator)));
  81 }
  82
  83 VKAPI_ATTR VkResult VKAPI_CALL createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
  84 {
  85         DE_UNREF(pAllocator);
  86         VK_NULL_RETURN((*pSampler = allocateNonDispHandle<Sampler, VkSampler>(device, pCreateInfo, pAllocator)));
  87 }
  88
  89 VKAPI_ATTR VkResult VKAPI_CALL createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
  90 {
  91         DE_UNREF(pAllocator);
  92         VK_NULL_RETURN((*pSetLayout = allocateNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(device, pCreateInfo, pAllocator)));
  93 }
  94
  95 VKAPI_ATTR VkResult VKAPI_CALL createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
  96 {
  97         DE_UNREF(pAllocator);
  98         VK_NULL_RETURN((*pDescriptorPool = allocateNonDispHandle<DescriptorPool, VkDescriptorPool>(device, pCreateInfo, pAllocator)));
  99 }
 100
 101 VKAPI_ATTR VkResult VKAPI_CALL createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
 102 {
 103         DE_UNREF(pAllocator);
 104         VK_NULL_RETURN((*pFramebuffer = allocateNonDispHandle<Framebuffer, VkFramebuffer>(device, pCreateInfo, pAllocator)));
 105 }
 106
 107 VKAPI_ATTR VkResult VKAPI_CALL createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
 108 {
 109         DE_UNREF(pAllocator);
 110         VK_NULL_RETURN((*pRenderPass = allocateNonDispHandle<RenderPass, VkRenderPass>(device, pCreateInfo, pAllocator)));
 111 }
 112
 113 VKAPI_ATTR VkResult VKAPI_CALL createCommandPool (VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
 114 {
 115         DE_UNREF(pAllocator);
 116         VK_NULL_RETURN((*pCommandPool = allocateNonDispHandle<CommandPool, VkCommandPool>(device, pCreateInfo, pAllocator)));
 117 }
 118
 119 VKAPI_ATTR VkResult VKAPI_CALL createSamplerYcbcrConversion (VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
 120 {
 121         DE_UNREF(pAllocator);
 122         VK_NULL_RETURN((*pYcbcrConversion = allocateNonDispHandle<SamplerYcbcrConversion, VkSamplerYcbcrConversion>(device, pCreateInfo, pAllocator)));
 123 }
 124
 125 VKAPI_ATTR VkResult VKAPI_CALL createDescriptorUpdateTemplate (VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
 126 {
 127         DE_UNREF(pAllocator);
 128         VK_NULL_RETURN((*pDescriptorUpdateTemplate = allocateNonDispHandle<DescriptorUpdateTemplate, VkDescriptorUpdateTemplate>(device, pCreateInfo, pAllocator)));
 129 }
 130
 131 VKAPI_ATTR VkResult VKAPI_CALL createRenderPass2 (VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
 132 {
 133         DE_UNREF(pAllocator);
 134         VK_NULL_RETURN((*pRenderPass = allocateNonDispHandle<RenderPass, VkRenderPass>(device, pCreateInfo, pAllocator)));
 135 }
 136
 137 VKAPI_ATTR VkResult VKAPI_CALL createPrivateDataSlot (VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
 138 {
 139         DE_UNREF(pAllocator);
 140         VK_NULL_RETURN((*pPrivateDataSlot = allocateNonDispHandle<PrivateDataSlot, VkPrivateDataSlot>(device, pCreateInfo, pAllocator)));
 141 }
 142
 143 VKAPI_ATTR VkResult VKAPI_CALL createSwapchainKHR (VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
 144 {
 145         DE_UNREF(pAllocator);
 146         VK_NULL_RETURN((*pSwapchain = allocateNonDispHandle<SwapchainKHR, VkSwapchainKHR>(device, pCreateInfo, pAllocator)));
 147 }
 148
 149 VKAPI_ATTR VkResult VKAPI_CALL createDisplayPlaneSurfaceKHR (VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 150 {
 151         DE_UNREF(pAllocator);
 152         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 153 }
 154
 155 VKAPI_ATTR VkResult VKAPI_CALL createDeferredOperationKHR (VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation)
 156 {
 157         DE_UNREF(pAllocator);
 158         VK_NULL_RETURN((*pDeferredOperation = allocateNonDispHandle<DeferredOperationKHR, VkDeferredOperationKHR>(device, pAllocator)));
 159 }
 160
 161 VKAPI_ATTR VkResult VKAPI_CALL createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback)
 162 {
 163         DE_UNREF(pAllocator);
 164         VK_NULL_RETURN((*pCallback = allocateNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(instance, pCreateInfo, pAllocator)));
 165 }
 166
 167 VKAPI_ATTR VkResult VKAPI_CALL createCuModuleNVX (VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule)
 168 {
 169         DE_UNREF(pAllocator);
 170         VK_NULL_RETURN((*pModule = allocateNonDispHandle<CuModuleNVX, VkCuModuleNVX>(device, pCreateInfo, pAllocator)));
 171 }
 172
 173 VKAPI_ATTR VkResult VKAPI_CALL createCuFunctionNVX (VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction)
 174 {
 175         DE_UNREF(pAllocator);
 176         VK_NULL_RETURN((*pFunction = allocateNonDispHandle<CuFunctionNVX, VkCuFunctionNVX>(device, pCreateInfo, pAllocator)));
 177 }
 178
 179 VKAPI_ATTR VkResult VKAPI_CALL createDebugUtilsMessengerEXT (VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger)
 180 {
 181         DE_UNREF(pAllocator);
 182         VK_NULL_RETURN((*pMessenger = allocateNonDispHandle<DebugUtilsMessengerEXT, VkDebugUtilsMessengerEXT>(instance, pCreateInfo, pAllocator)));
 183 }
 184
 185 VKAPI_ATTR VkResult VKAPI_CALL createValidationCacheEXT (VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache)
 186 {
 187         DE_UNREF(pAllocator);
 188         VK_NULL_RETURN((*pValidationCache = allocateNonDispHandle<ValidationCacheEXT, VkValidationCacheEXT>(device, pCreateInfo, pAllocator)));
 189 }
 190
 191 VKAPI_ATTR VkResult VKAPI_CALL createAccelerationStructureNV (VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure)
 192 {
 193         DE_UNREF(pAllocator);
 194         VK_NULL_RETURN((*pAccelerationStructure = allocateNonDispHandle<AccelerationStructureNV, VkAccelerationStructureNV>(device, pCreateInfo, pAllocator)));
 195 }
 196
 197 VKAPI_ATTR VkResult VKAPI_CALL createHeadlessSurfaceEXT (VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 198 {
 199         DE_UNREF(pAllocator);
 200         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 201 }
 202
 203 VKAPI_ATTR VkResult VKAPI_CALL createIndirectCommandsLayoutNV (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout)
 204 {
 205         DE_UNREF(pAllocator);
 206         VK_NULL_RETURN((*pIndirectCommandsLayout = allocateNonDispHandle<IndirectCommandsLayoutNV, VkIndirectCommandsLayoutNV>(device, pCreateInfo, pAllocator)));
 207 }
 208
 209 VKAPI_ATTR VkResult VKAPI_CALL createAccelerationStructureKHR (VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure)
 210 {
 211         DE_UNREF(pAllocator);
 212         VK_NULL_RETURN((*pAccelerationStructure = allocateNonDispHandle<AccelerationStructureKHR, VkAccelerationStructureKHR>(device, pCreateInfo, pAllocator)));
 213 }
 214
 215 VKAPI_ATTR VkResult VKAPI_CALL createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 216 {
 217         DE_UNREF(pAllocator);
 218         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 219 }
 220
 221 VKAPI_ATTR VkResult VKAPI_CALL createVideoSessionKHR (VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession)
 222 {
 223         DE_UNREF(pAllocator);
 224         VK_NULL_RETURN((*pVideoSession = allocateNonDispHandle<VideoSessionKHR, VkVideoSessionKHR>(device, pCreateInfo, pAllocator)));
 225 }
 226
 227 VKAPI_ATTR VkResult VKAPI_CALL createVideoSessionParametersKHR (VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters)
 228 {
 229         DE_UNREF(pAllocator);
 230         VK_NULL_RETURN((*pVideoSessionParameters = allocateNonDispHandle<VideoSessionParametersKHR, VkVideoSessionParametersKHR>(device, pCreateInfo, pAllocator)));
 231 }
 232
 233 VKAPI_ATTR VkResult VKAPI_CALL createImagePipeSurfaceFUCHSIA (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 234 {
 235         DE_UNREF(pAllocator);
 236         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 237 }
 238
 239 VKAPI_ATTR VkResult VKAPI_CALL createBufferCollectionFUCHSIA (VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection)
 240 {
 241         DE_UNREF(pAllocator);
 242         VK_NULL_RETURN((*pCollection = allocateNonDispHandle<BufferCollectionFUCHSIA, VkBufferCollectionFUCHSIA>(device, pCreateInfo, pAllocator)));
 243 }
 244
 245 VKAPI_ATTR VkResult VKAPI_CALL createStreamDescriptorSurfaceGGP (VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 246 {
 247         DE_UNREF(pAllocator);
 248         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 249 }
 250
 251 VKAPI_ATTR VkResult VKAPI_CALL createIOSSurfaceMVK (VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 252 {
 253         DE_UNREF(pAllocator);
 254         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 255 }
 256
 257 VKAPI_ATTR VkResult VKAPI_CALL createMacOSSurfaceMVK (VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 258 {
 259         DE_UNREF(pAllocator);
 260         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 261 }
 262
 263 VKAPI_ATTR VkResult VKAPI_CALL createMetalSurfaceEXT (VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 264 {
 265         DE_UNREF(pAllocator);
 266         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 267 }
 268
 269 VKAPI_ATTR VkResult VKAPI_CALL createViSurfaceNN (VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 270 {
 271         DE_UNREF(pAllocator);
 272         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 273 }
 274
 275 VKAPI_ATTR VkResult VKAPI_CALL createWaylandSurfaceKHR (VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 276 {
 277         DE_UNREF(pAllocator);
 278         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 279 }
 280
 281 VKAPI_ATTR VkResult VKAPI_CALL createWin32SurfaceKHR (VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 282 {
 283         DE_UNREF(pAllocator);
 284         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 285 }
 286
 287 VKAPI_ATTR VkResult VKAPI_CALL createXcbSurfaceKHR (VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 288 {
 289         DE_UNREF(pAllocator);
 290         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 291 }
 292
 293 VKAPI_ATTR VkResult VKAPI_CALL createXlibSurfaceKHR (VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 294 {
 295         DE_UNREF(pAllocator);
 296         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 297 }
 298
 299 VKAPI_ATTR void VKAPI_CALL destroyInstance (VkInstance instance, const VkAllocationCallbacks* pAllocator)
 300 {
 301         freeHandle<Instance, VkInstance>(instance, pAllocator);
 302 }
 303
 304 VKAPI_ATTR void VKAPI_CALL destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator)
 305 {
 306         freeHandle<Device, VkDevice>(device, pAllocator);
 307 }
 308
 309 VKAPI_ATTR void VKAPI_CALL freeMemory (VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
 310 {
 311         DE_UNREF(device);
 312         freeNonDispHandle<DeviceMemory, VkDeviceMemory>(memory, pAllocator);
 313 }
 314
 315 VKAPI_ATTR void VKAPI_CALL destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
 316 {
 317         DE_UNREF(device);
 318         freeNonDispHandle<Fence, VkFence>(fence, pAllocator);
 319 }
 320
 321 VKAPI_ATTR void VKAPI_CALL destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
 322 {
 323         DE_UNREF(device);
 324         freeNonDispHandle<Semaphore, VkSemaphore>(semaphore, pAllocator);
 325 }
 326
 327 VKAPI_ATTR void VKAPI_CALL destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
 328 {
 329         DE_UNREF(device);
 330         freeNonDispHandle<Event, VkEvent>(event, pAllocator);
 331 }
 332
 333 VKAPI_ATTR void VKAPI_CALL destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
 334 {
 335         DE_UNREF(device);
 336         freeNonDispHandle<QueryPool, VkQueryPool>(queryPool, pAllocator);
 337 }
 338
 339 VKAPI_ATTR void VKAPI_CALL destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
 340 {
 341         DE_UNREF(device);
 342         freeNonDispHandle<Buffer, VkBuffer>(buffer, pAllocator);
 343 }
 344
 345 VKAPI_ATTR void VKAPI_CALL destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
 346 {
 347         DE_UNREF(device);
 348         freeNonDispHandle<BufferView, VkBufferView>(bufferView, pAllocator);
 349 }
 350
 351 VKAPI_ATTR void VKAPI_CALL destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 352 {
 353         DE_UNREF(device);
 354         freeNonDispHandle<Image, VkImage>(image, pAllocator);
 355 }
 356
 357 VKAPI_ATTR void VKAPI_CALL destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
 358 {
 359         DE_UNREF(device);
 360         freeNonDispHandle<ImageView, VkImageView>(imageView, pAllocator);
 361 }
 362
 363 VKAPI_ATTR void VKAPI_CALL destroyShaderModule (VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
 364 {
 365         DE_UNREF(device);
 366         freeNonDispHandle<ShaderModule, VkShaderModule>(shaderModule, pAllocator);
 367 }
 368
 369 VKAPI_ATTR void VKAPI_CALL destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
 370 {
 371         DE_UNREF(device);
 372         freeNonDispHandle<PipelineCache, VkPipelineCache>(pipelineCache, pAllocator);
 373 }
 374
 375 VKAPI_ATTR void VKAPI_CALL destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
 376 {
 377         DE_UNREF(device);
 378         freeNonDispHandle<Pipeline, VkPipeline>(pipeline, pAllocator);
 379 }
 380
 381 VKAPI_ATTR void VKAPI_CALL destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
 382 {
 383         DE_UNREF(device);
 384         freeNonDispHandle<PipelineLayout, VkPipelineLayout>(pipelineLayout, pAllocator);
 385 }
 386
 387 VKAPI_ATTR void VKAPI_CALL destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
 388 {
 389         DE_UNREF(device);
 390         freeNonDispHandle<Sampler, VkSampler>(sampler, pAllocator);
 391 }
 392
 393 VKAPI_ATTR void VKAPI_CALL destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
 394 {
 395         DE_UNREF(device);
 396         freeNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(descriptorSetLayout, pAllocator);
 397 }
 398
 399 VKAPI_ATTR void VKAPI_CALL destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
 400 {
 401         DE_UNREF(device);
 402         freeNonDispHandle<DescriptorPool, VkDescriptorPool>(descriptorPool, pAllocator);
 403 }
 404
 405 VKAPI_ATTR void VKAPI_CALL destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
 406 {
 407         DE_UNREF(device);
 408         freeNonDispHandle<Framebuffer, VkFramebuffer>(framebuffer, pAllocator);
 409 }
 410
 411 VKAPI_ATTR void VKAPI_CALL destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
 412 {
 413         DE_UNREF(device);
 414         freeNonDispHandle<RenderPass, VkRenderPass>(renderPass, pAllocator);
 415 }
 416
 417 VKAPI_ATTR void VKAPI_CALL destroyCommandPool (VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
 418 {
 419         DE_UNREF(device);
 420         freeNonDispHandle<CommandPool, VkCommandPool>(commandPool, pAllocator);
 421 }
 422
 423 VKAPI_ATTR void VKAPI_CALL destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
 424 {
 425         DE_UNREF(device);
 426         freeNonDispHandle<SamplerYcbcrConversion, VkSamplerYcbcrConversion>(ycbcrConversion, pAllocator);
 427 }
 428
 429 VKAPI_ATTR void VKAPI_CALL destroyDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
 430 {
 431         DE_UNREF(device);
 432         freeNonDispHandle<DescriptorUpdateTemplate, VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, pAllocator);
 433 }
 434
 435 VKAPI_ATTR void VKAPI_CALL destroyPrivateDataSlot (VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
 436 {
 437         DE_UNREF(device);
 438         freeNonDispHandle<PrivateDataSlot, VkPrivateDataSlot>(privateDataSlot, pAllocator);
 439 }
 440
 441 VKAPI_ATTR void VKAPI_CALL destroySurfaceKHR (VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator)
 442 {
 443         DE_UNREF(instance);
 444         freeNonDispHandle<SurfaceKHR, VkSurfaceKHR>(surface, pAllocator);
 445 }
 446
 447 VKAPI_ATTR void VKAPI_CALL destroySwapchainKHR (VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
 448 {
 449         DE_UNREF(device);
 450         freeNonDispHandle<SwapchainKHR, VkSwapchainKHR>(swapchain, pAllocator);
 451 }
 452
 453 VKAPI_ATTR void VKAPI_CALL destroyDeferredOperationKHR (VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator)
 454 {
 455         DE_UNREF(device);
 456         freeNonDispHandle<DeferredOperationKHR, VkDeferredOperationKHR>(operation, pAllocator);
 457 }
 458
 459 VKAPI_ATTR void VKAPI_CALL destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator)
 460 {
 461         DE_UNREF(instance);
 462         freeNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(callback, pAllocator);
 463 }
 464
 465 VKAPI_ATTR void VKAPI_CALL destroyCuModuleNVX (VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator)
 466 {
 467         DE_UNREF(device);
 468         freeNonDispHandle<CuModuleNVX, VkCuModuleNVX>(module, pAllocator);
 469 }
 470
 471 VKAPI_ATTR void VKAPI_CALL destroyCuFunctionNVX (VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator)
 472 {
 473         DE_UNREF(device);
 474         freeNonDispHandle<CuFunctionNVX, VkCuFunctionNVX>(function, pAllocator);
 475 }
 476
 477 VKAPI_ATTR void VKAPI_CALL destroyDebugUtilsMessengerEXT (VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator)
 478 {
 479         DE_UNREF(instance);
 480         freeNonDispHandle<DebugUtilsMessengerEXT, VkDebugUtilsMessengerEXT>(messenger, pAllocator);
 481 }
 482
 483 VKAPI_ATTR void VKAPI_CALL destroyValidationCacheEXT (VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator)
 484 {
 485         DE_UNREF(device);
 486         freeNonDispHandle<ValidationCacheEXT, VkValidationCacheEXT>(validationCache, pAllocator);
 487 }
 488
 489 VKAPI_ATTR void VKAPI_CALL destroyAccelerationStructureNV (VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator)
 490 {
 491         DE_UNREF(device);
 492         freeNonDispHandle<AccelerationStructureNV, VkAccelerationStructureNV>(accelerationStructure, pAllocator);
 493 }
 494
 495 VKAPI_ATTR void VKAPI_CALL destroyIndirectCommandsLayoutNV (VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator)
 496 {
 497         DE_UNREF(device);
 498         freeNonDispHandle<IndirectCommandsLayoutNV, VkIndirectCommandsLayoutNV>(indirectCommandsLayout, pAllocator);
 499 }
 500
 501 VKAPI_ATTR void VKAPI_CALL destroyAccelerationStructureKHR (VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator)
 502 {
 503         DE_UNREF(device);
 504         freeNonDispHandle<AccelerationStructureKHR, VkAccelerationStructureKHR>(accelerationStructure, pAllocator);
 505 }
 506
 507 VKAPI_ATTR void VKAPI_CALL destroyVideoSessionKHR (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator)
 508 {
 509         DE_UNREF(device);
 510         freeNonDispHandle<VideoSessionKHR, VkVideoSessionKHR>(videoSession, pAllocator);
 511 }
 512
 513 VKAPI_ATTR void VKAPI_CALL destroyVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator)
 514 {
 515         DE_UNREF(device);
 516         freeNonDispHandle<VideoSessionParametersKHR, VkVideoSessionParametersKHR>(videoSessionParameters, pAllocator);
 517 }
 518
 519 VKAPI_ATTR void VKAPI_CALL destroyBufferCollectionFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator)
 520 {
 521         DE_UNREF(device);
 522         freeNonDispHandle<BufferCollectionFUCHSIA, VkBufferCollectionFUCHSIA>(collection, pAllocator);
 523 }
 524
 525 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (uint32_t* pPropertyCount, VkLayerProperties* pProperties)
 526 {
 527         DE_UNREF(pPropertyCount);
 528         DE_UNREF(pProperties);
 529         return VK_SUCCESS;
 530 }
 531
 532 VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
 533 {
 534         DE_UNREF(physicalDevice);
 535         DE_UNREF(pPropertyCount);
 536         DE_UNREF(pProperties);
 537         return VK_SUCCESS;
 538 }
 539
 540 VKAPI_ATTR VkResult VKAPI_CALL queueSubmit (VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
 541 {
 542         DE_UNREF(queue);
 543         DE_UNREF(submitCount);
 544         DE_UNREF(pSubmits);
 545         DE_UNREF(fence);
 546         return VK_SUCCESS;
 547 }
 548
 549 VKAPI_ATTR VkResult VKAPI_CALL queueWaitIdle (VkQueue queue)
 550 {
 551         DE_UNREF(queue);
 552         return VK_SUCCESS;
 553 }
 554
 555 VKAPI_ATTR VkResult VKAPI_CALL deviceWaitIdle (VkDevice device)
 556 {
 557         DE_UNREF(device);
 558         return VK_SUCCESS;
 559 }
 560
 561 VKAPI_ATTR VkResult VKAPI_CALL flushMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 562 {
 563         DE_UNREF(device);
 564         DE_UNREF(memoryRangeCount);
 565         DE_UNREF(pMemoryRanges);
 566         return VK_SUCCESS;
 567 }
 568
 569 VKAPI_ATTR VkResult VKAPI_CALL invalidateMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 570 {
 571         DE_UNREF(device);
 572         DE_UNREF(memoryRangeCount);
 573         DE_UNREF(pMemoryRanges);
 574         return VK_SUCCESS;
 575 }
 576
 577 VKAPI_ATTR void VKAPI_CALL getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
 578 {
 579         DE_UNREF(device);
 580         DE_UNREF(memory);
 581         DE_UNREF(pCommittedMemoryInBytes);
 582 }
 583
 584 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 585 {
 586         DE_UNREF(device);
 587         DE_UNREF(buffer);
 588         DE_UNREF(memory);
 589         DE_UNREF(memoryOffset);
 590         return VK_SUCCESS;
 591 }
 592
 593 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 594 {
 595         DE_UNREF(device);
 596         DE_UNREF(image);
 597         DE_UNREF(memory);
 598         DE_UNREF(memoryOffset);
 599         return VK_SUCCESS;
 600 }
 601
 602 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements (VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 603 {
 604         DE_UNREF(device);
 605         DE_UNREF(image);
 606         DE_UNREF(pSparseMemoryRequirementCount);
 607         DE_UNREF(pSparseMemoryRequirements);
 608 }
 609
 610 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
 611 {
 612         DE_UNREF(physicalDevice);
 613         DE_UNREF(format);
 614         DE_UNREF(type);
 615         DE_UNREF(samples);
 616         DE_UNREF(usage);
 617         DE_UNREF(tiling);
 618         DE_UNREF(pPropertyCount);
 619         DE_UNREF(pProperties);
 620 }
 621
 622 VKAPI_ATTR VkResult VKAPI_CALL queueBindSparse (VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
 623 {
 624         DE_UNREF(queue);
 625         DE_UNREF(bindInfoCount);
 626         DE_UNREF(pBindInfo);
 627         DE_UNREF(fence);
 628         return VK_SUCCESS;
 629 }
 630
 631 VKAPI_ATTR VkResult VKAPI_CALL resetFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences)
 632 {
 633         DE_UNREF(device);
 634         DE_UNREF(fenceCount);
 635         DE_UNREF(pFences);
 636         return VK_SUCCESS;
 637 }
 638
 639 VKAPI_ATTR VkResult VKAPI_CALL getFenceStatus (VkDevice device, VkFence fence)
 640 {
 641         DE_UNREF(device);
 642         DE_UNREF(fence);
 643         return VK_SUCCESS;
 644 }
 645
 646 VKAPI_ATTR VkResult VKAPI_CALL waitForFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
 647 {
 648         DE_UNREF(device);
 649         DE_UNREF(fenceCount);
 650         DE_UNREF(pFences);
 651         DE_UNREF(waitAll);
 652         DE_UNREF(timeout);
 653         return VK_SUCCESS;
 654 }
 655
 656 VKAPI_ATTR VkResult VKAPI_CALL getEventStatus (VkDevice device, VkEvent event)
 657 {
 658         DE_UNREF(device);
 659         DE_UNREF(event);
 660         return VK_SUCCESS;
 661 }
 662
 663 VKAPI_ATTR VkResult VKAPI_CALL setEvent (VkDevice device, VkEvent event)
 664 {
 665         DE_UNREF(device);
 666         DE_UNREF(event);
 667         return VK_SUCCESS;
 668 }
 669
 670 VKAPI_ATTR VkResult VKAPI_CALL resetEvent (VkDevice device, VkEvent event)
 671 {
 672         DE_UNREF(device);
 673         DE_UNREF(event);
 674         return VK_SUCCESS;
 675 }
 676
 677 VKAPI_ATTR VkResult VKAPI_CALL getQueryPoolResults (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
 678 {
 679         DE_UNREF(device);
 680         DE_UNREF(queryPool);
 681         DE_UNREF(firstQuery);
 682         DE_UNREF(queryCount);
 683         DE_UNREF(dataSize);
 684         DE_UNREF(pData);
 685         DE_UNREF(stride);
 686         DE_UNREF(flags);
 687         return VK_SUCCESS;
 688 }
 689
 690 VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
 691 {
 692         DE_UNREF(device);
 693         DE_UNREF(image);
 694         DE_UNREF(pSubresource);
 695         DE_UNREF(pLayout);
 696 }
 697
 698 VKAPI_ATTR VkResult VKAPI_CALL getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
 699 {
 700         DE_UNREF(device);
 701         DE_UNREF(pipelineCache);
 702         DE_UNREF(pDataSize);
 703         DE_UNREF(pData);
 704         return VK_SUCCESS;
 705 }
 706
 707 VKAPI_ATTR VkResult VKAPI_CALL mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
 708 {
 709         DE_UNREF(device);
 710         DE_UNREF(dstCache);
 711         DE_UNREF(srcCacheCount);
 712         DE_UNREF(pSrcCaches);
 713         return VK_SUCCESS;
 714 }
 715
 716 VKAPI_ATTR void VKAPI_CALL updateDescriptorSets (VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
 717 {
 718         DE_UNREF(device);
 719         DE_UNREF(descriptorWriteCount);
 720         DE_UNREF(pDescriptorWrites);
 721         DE_UNREF(descriptorCopyCount);
 722         DE_UNREF(pDescriptorCopies);
 723 }
 724
 725 VKAPI_ATTR void VKAPI_CALL getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
 726 {
 727         DE_UNREF(device);
 728         DE_UNREF(renderPass);
 729         DE_UNREF(pGranularity);
 730 }
 731
 732 VKAPI_ATTR VkResult VKAPI_CALL resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 733 {
 734         DE_UNREF(device);
 735         DE_UNREF(commandPool);
 736         DE_UNREF(flags);
 737         return VK_SUCCESS;
 738 }
 739
 740 VKAPI_ATTR VkResult VKAPI_CALL beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
 741 {
 742         DE_UNREF(commandBuffer);
 743         DE_UNREF(pBeginInfo);
 744         return VK_SUCCESS;
 745 }
 746
 747 VKAPI_ATTR VkResult VKAPI_CALL endCommandBuffer (VkCommandBuffer commandBuffer)
 748 {
 749         DE_UNREF(commandBuffer);
 750         return VK_SUCCESS;
 751 }
 752
 753 VKAPI_ATTR VkResult VKAPI_CALL resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 754 {
 755         DE_UNREF(commandBuffer);
 756         DE_UNREF(flags);
 757         return VK_SUCCESS;
 758 }
 759
 760 VKAPI_ATTR void VKAPI_CALL cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 761 {
 762         DE_UNREF(commandBuffer);
 763         DE_UNREF(pipelineBindPoint);
 764         DE_UNREF(pipeline);
 765 }
 766
 767 VKAPI_ATTR void VKAPI_CALL cmdSetViewport (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
 768 {
 769         DE_UNREF(commandBuffer);
 770         DE_UNREF(firstViewport);
 771         DE_UNREF(viewportCount);
 772         DE_UNREF(pViewports);
 773 }
 774
 775 VKAPI_ATTR void VKAPI_CALL cmdSetScissor (VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
 776 {
 777         DE_UNREF(commandBuffer);
 778         DE_UNREF(firstScissor);
 779         DE_UNREF(scissorCount);
 780         DE_UNREF(pScissors);
 781 }
 782
 783 VKAPI_ATTR void VKAPI_CALL cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth)
 784 {
 785         DE_UNREF(commandBuffer);
 786         DE_UNREF(lineWidth);
 787 }
 788
 789 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 790 {
 791         DE_UNREF(commandBuffer);
 792         DE_UNREF(depthBiasConstantFactor);
 793         DE_UNREF(depthBiasClamp);
 794         DE_UNREF(depthBiasSlopeFactor);
 795 }
 796
 797 VKAPI_ATTR void VKAPI_CALL cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4])
 798 {
 799         DE_UNREF(commandBuffer);
 800         DE_UNREF(blendConstants);
 801 }
 802
 803 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 804 {
 805         DE_UNREF(commandBuffer);
 806         DE_UNREF(minDepthBounds);
 807         DE_UNREF(maxDepthBounds);
 808 }
 809
 810 VKAPI_ATTR void VKAPI_CALL cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 811 {
 812         DE_UNREF(commandBuffer);
 813         DE_UNREF(faceMask);
 814         DE_UNREF(compareMask);
 815 }
 816
 817 VKAPI_ATTR void VKAPI_CALL cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 818 {
 819         DE_UNREF(commandBuffer);
 820         DE_UNREF(faceMask);
 821         DE_UNREF(writeMask);
 822 }
 823
 824 VKAPI_ATTR void VKAPI_CALL cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 825 {
 826         DE_UNREF(commandBuffer);
 827         DE_UNREF(faceMask);
 828         DE_UNREF(reference);
 829 }
 830
 831 VKAPI_ATTR void VKAPI_CALL cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
 832 {
 833         DE_UNREF(commandBuffer);
 834         DE_UNREF(pipelineBindPoint);
 835         DE_UNREF(layout);
 836         DE_UNREF(firstSet);
 837         DE_UNREF(descriptorSetCount);
 838         DE_UNREF(pDescriptorSets);
 839         DE_UNREF(dynamicOffsetCount);
 840         DE_UNREF(pDynamicOffsets);
 841 }
 842
 843 VKAPI_ATTR void VKAPI_CALL cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 844 {
 845         DE_UNREF(commandBuffer);
 846         DE_UNREF(buffer);
 847         DE_UNREF(offset);
 848         DE_UNREF(indexType);
 849 }
 850
 851 VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
 852 {
 853         DE_UNREF(commandBuffer);
 854         DE_UNREF(firstBinding);
 855         DE_UNREF(bindingCount);
 856         DE_UNREF(pBuffers);
 857         DE_UNREF(pOffsets);
 858 }
 859
 860 VKAPI_ATTR void VKAPI_CALL cmdDraw (VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 861 {
 862         DE_UNREF(commandBuffer);
 863         DE_UNREF(vertexCount);
 864         DE_UNREF(instanceCount);
 865         DE_UNREF(firstVertex);
 866         DE_UNREF(firstInstance);
 867 }
 868
 869 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexed (VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 870 {
 871         DE_UNREF(commandBuffer);
 872         DE_UNREF(indexCount);
 873         DE_UNREF(instanceCount);
 874         DE_UNREF(firstIndex);
 875         DE_UNREF(vertexOffset);
 876         DE_UNREF(firstInstance);
 877 }
 878
 879 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 880 {
 881         DE_UNREF(commandBuffer);
 882         DE_UNREF(buffer);
 883         DE_UNREF(offset);
 884         DE_UNREF(drawCount);
 885         DE_UNREF(stride);
 886 }
 887
 888 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 889 {
 890         DE_UNREF(commandBuffer);
 891         DE_UNREF(buffer);
 892         DE_UNREF(offset);
 893         DE_UNREF(drawCount);
 894         DE_UNREF(stride);
 895 }
 896
 897 VKAPI_ATTR void VKAPI_CALL cmdDispatch (VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 898 {
 899         DE_UNREF(commandBuffer);
 900         DE_UNREF(groupCountX);
 901         DE_UNREF(groupCountY);
 902         DE_UNREF(groupCountZ);
 903 }
 904
 905 VKAPI_ATTR void VKAPI_CALL cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 906 {
 907         DE_UNREF(commandBuffer);
 908         DE_UNREF(buffer);
 909         DE_UNREF(offset);
 910 }
 911
 912 VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
 913 {
 914         DE_UNREF(commandBuffer);
 915         DE_UNREF(srcBuffer);
 916         DE_UNREF(dstBuffer);
 917         DE_UNREF(regionCount);
 918         DE_UNREF(pRegions);
 919 }
 920
 921 VKAPI_ATTR void VKAPI_CALL cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
 922 {
 923         DE_UNREF(commandBuffer);
 924         DE_UNREF(srcImage);
 925         DE_UNREF(srcImageLayout);
 926         DE_UNREF(dstImage);
 927         DE_UNREF(dstImageLayout);
 928         DE_UNREF(regionCount);
 929         DE_UNREF(pRegions);
 930 }
 931
 932 VKAPI_ATTR void VKAPI_CALL cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
 933 {
 934         DE_UNREF(commandBuffer);
 935         DE_UNREF(srcImage);
 936         DE_UNREF(srcImageLayout);
 937         DE_UNREF(dstImage);
 938         DE_UNREF(dstImageLayout);
 939         DE_UNREF(regionCount);
 940         DE_UNREF(pRegions);
 941         DE_UNREF(filter);
 942 }
 943
 944 VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
 945 {
 946         DE_UNREF(commandBuffer);
 947         DE_UNREF(srcBuffer);
 948         DE_UNREF(dstImage);
 949         DE_UNREF(dstImageLayout);
 950         DE_UNREF(regionCount);
 951         DE_UNREF(pRegions);
 952 }
 953
 954 VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
 955 {
 956         DE_UNREF(commandBuffer);
 957         DE_UNREF(srcImage);
 958         DE_UNREF(srcImageLayout);
 959         DE_UNREF(dstBuffer);
 960         DE_UNREF(regionCount);
 961         DE_UNREF(pRegions);
 962 }
 963
 964 VKAPI_ATTR void VKAPI_CALL cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
 965 {
 966         DE_UNREF(commandBuffer);
 967         DE_UNREF(dstBuffer);
 968         DE_UNREF(dstOffset);
 969         DE_UNREF(dataSize);
 970         DE_UNREF(pData);
 971 }
 972
 973 VKAPI_ATTR void VKAPI_CALL cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
 974 {
 975         DE_UNREF(commandBuffer);
 976         DE_UNREF(dstBuffer);
 977         DE_UNREF(dstOffset);
 978         DE_UNREF(size);
 979         DE_UNREF(data);
 980 }
 981
 982 VKAPI_ATTR void VKAPI_CALL cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
 983 {
 984         DE_UNREF(commandBuffer);
 985         DE_UNREF(image);
 986         DE_UNREF(imageLayout);
 987         DE_UNREF(pColor);
 988         DE_UNREF(rangeCount);
 989         DE_UNREF(pRanges);
 990 }
 991
 992 VKAPI_ATTR void VKAPI_CALL cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
 993 {
 994         DE_UNREF(commandBuffer);
 995         DE_UNREF(image);
 996         DE_UNREF(imageLayout);
 997         DE_UNREF(pDepthStencil);
 998         DE_UNREF(rangeCount);
 999         DE_UNREF(pRanges);
1000 }
1001
1002 VKAPI_ATTR void VKAPI_CALL cmdClearAttachments (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
1003 {
1004         DE_UNREF(commandBuffer);
1005         DE_UNREF(attachmentCount);
1006         DE_UNREF(pAttachments);
1007         DE_UNREF(rectCount);
1008         DE_UNREF(pRects);
1009 }
1010
1011 VKAPI_ATTR void VKAPI_CALL cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
1012 {
1013         DE_UNREF(commandBuffer);
1014         DE_UNREF(srcImage);
1015         DE_UNREF(srcImageLayout);
1016         DE_UNREF(dstImage);
1017         DE_UNREF(dstImageLayout);
1018         DE_UNREF(regionCount);
1019         DE_UNREF(pRegions);
1020 }
1021
1022 VKAPI_ATTR void VKAPI_CALL cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1023 {
1024         DE_UNREF(commandBuffer);
1025         DE_UNREF(event);
1026         DE_UNREF(stageMask);
1027 }
1028
1029 VKAPI_ATTR void VKAPI_CALL cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1030 {
1031         DE_UNREF(commandBuffer);
1032         DE_UNREF(event);
1033         DE_UNREF(stageMask);
1034 }
1035
1036 VKAPI_ATTR void VKAPI_CALL cmdWaitEvents (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
1037 {
1038         DE_UNREF(commandBuffer);
1039         DE_UNREF(eventCount);
1040         DE_UNREF(pEvents);
1041         DE_UNREF(srcStageMask);
1042         DE_UNREF(dstStageMask);
1043         DE_UNREF(memoryBarrierCount);
1044         DE_UNREF(pMemoryBarriers);
1045         DE_UNREF(bufferMemoryBarrierCount);
1046         DE_UNREF(pBufferMemoryBarriers);
1047         DE_UNREF(imageMemoryBarrierCount);
1048         DE_UNREF(pImageMemoryBarriers);
1049 }
1050
1051 VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
1052 {
1053         DE_UNREF(commandBuffer);
1054         DE_UNREF(srcStageMask);
1055         DE_UNREF(dstStageMask);
1056         DE_UNREF(dependencyFlags);
1057         DE_UNREF(memoryBarrierCount);
1058         DE_UNREF(pMemoryBarriers);
1059         DE_UNREF(bufferMemoryBarrierCount);
1060         DE_UNREF(pBufferMemoryBarriers);
1061         DE_UNREF(imageMemoryBarrierCount);
1062         DE_UNREF(pImageMemoryBarriers);
1063 }
1064
1065 VKAPI_ATTR void VKAPI_CALL cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
1066 {
1067         DE_UNREF(commandBuffer);
1068         DE_UNREF(queryPool);
1069         DE_UNREF(query);
1070         DE_UNREF(flags);
1071 }
1072
1073 VKAPI_ATTR void VKAPI_CALL cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
1074 {
1075         DE_UNREF(commandBuffer);
1076         DE_UNREF(queryPool);
1077         DE_UNREF(query);
1078 }
1079
1080 VKAPI_ATTR void VKAPI_CALL cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
1081 {
1082         DE_UNREF(commandBuffer);
1083         DE_UNREF(queryPool);
1084         DE_UNREF(firstQuery);
1085         DE_UNREF(queryCount);
1086 }
1087
1088 VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
1089 {
1090         DE_UNREF(commandBuffer);
1091         DE_UNREF(pipelineStage);
1092         DE_UNREF(queryPool);
1093         DE_UNREF(query);
1094 }
1095
1096 VKAPI_ATTR void VKAPI_CALL cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
1097 {
1098         DE_UNREF(commandBuffer);
1099         DE_UNREF(queryPool);
1100         DE_UNREF(firstQuery);
1101         DE_UNREF(queryCount);
1102         DE_UNREF(dstBuffer);
1103         DE_UNREF(dstOffset);
1104         DE_UNREF(stride);
1105         DE_UNREF(flags);
1106 }
1107
1108 VKAPI_ATTR void VKAPI_CALL cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
1109 {
1110         DE_UNREF(commandBuffer);
1111         DE_UNREF(layout);
1112         DE_UNREF(stageFlags);
1113         DE_UNREF(offset);
1114         DE_UNREF(size);
1115         DE_UNREF(pValues);
1116 }
1117
1118 VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
1119 {
1120         DE_UNREF(commandBuffer);
1121         DE_UNREF(pRenderPassBegin);
1122         DE_UNREF(contents);
1123 }
1124
1125 VKAPI_ATTR void VKAPI_CALL cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents)
1126 {
1127         DE_UNREF(commandBuffer);
1128         DE_UNREF(contents);
1129 }
1130
1131 VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass (VkCommandBuffer commandBuffer)
1132 {
1133         DE_UNREF(commandBuffer);
1134 }
1135
1136 VKAPI_ATTR void VKAPI_CALL cmdExecuteCommands (VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
1137 {
1138         DE_UNREF(commandBuffer);
1139         DE_UNREF(commandBufferCount);
1140         DE_UNREF(pCommandBuffers);
1141 }
1142
1143 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceVersion (uint32_t* pApiVersion)
1144 {
1145         DE_UNREF(pApiVersion);
1146         return VK_SUCCESS;
1147 }
1148
1149 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
1150 {
1151         DE_UNREF(device);
1152         DE_UNREF(bindInfoCount);
1153         DE_UNREF(pBindInfos);
1154         return VK_SUCCESS;
1155 }
1156
1157 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1158 {
1159         DE_UNREF(device);
1160         DE_UNREF(bindInfoCount);
1161         DE_UNREF(pBindInfos);
1162         return VK_SUCCESS;
1163 }
1164
1165 VKAPI_ATTR void VKAPI_CALL getDeviceGroupPeerMemoryFeatures (VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
1166 {
1167         DE_UNREF(device);
1168         DE_UNREF(heapIndex);
1169         DE_UNREF(localDeviceIndex);
1170         DE_UNREF(remoteDeviceIndex);
1171         DE_UNREF(pPeerMemoryFeatures);
1172 }
1173
1174 VKAPI_ATTR void VKAPI_CALL cmdSetDeviceMask (VkCommandBuffer commandBuffer, uint32_t deviceMask)
1175 {
1176         DE_UNREF(commandBuffer);
1177         DE_UNREF(deviceMask);
1178 }
1179
1180 VKAPI_ATTR void VKAPI_CALL cmdDispatchBase (VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
1181 {
1182         DE_UNREF(commandBuffer);
1183         DE_UNREF(baseGroupX);
1184         DE_UNREF(baseGroupY);
1185         DE_UNREF(baseGroupZ);
1186         DE_UNREF(groupCountX);
1187         DE_UNREF(groupCountY);
1188         DE_UNREF(groupCountZ);
1189 }
1190
1191 VKAPI_ATTR VkResult VKAPI_CALL enumeratePhysicalDeviceGroups (VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
1192 {
1193         DE_UNREF(instance);
1194         DE_UNREF(pPhysicalDeviceGroupCount);
1195         DE_UNREF(pPhysicalDeviceGroupProperties);
1196         return VK_SUCCESS;
1197 }
1198
1199 VKAPI_ATTR void VKAPI_CALL getImageMemoryRequirements2 (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1200 {
1201         DE_UNREF(device);
1202         DE_UNREF(pInfo);
1203         DE_UNREF(pMemoryRequirements);
1204 }
1205
1206 VKAPI_ATTR void VKAPI_CALL getBufferMemoryRequirements2 (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1207 {
1208         DE_UNREF(device);
1209         DE_UNREF(pInfo);
1210         DE_UNREF(pMemoryRequirements);
1211 }
1212
1213 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements2 (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1214 {
1215         DE_UNREF(device);
1216         DE_UNREF(pInfo);
1217         DE_UNREF(pSparseMemoryRequirementCount);
1218         DE_UNREF(pSparseMemoryRequirements);
1219 }
1220
1221 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
1222 {
1223         DE_UNREF(physicalDevice);
1224         DE_UNREF(pFeatures);
1225 }
1226
1227 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
1228 {
1229         DE_UNREF(physicalDevice);
1230         DE_UNREF(pProperties);
1231 }
1232
1233 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFormatProperties2 (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
1234 {
1235         DE_UNREF(physicalDevice);
1236         DE_UNREF(format);
1237         DE_UNREF(pFormatProperties);
1238 }
1239
1240 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
1241 {
1242         DE_UNREF(physicalDevice);
1243         DE_UNREF(pImageFormatInfo);
1244         DE_UNREF(pImageFormatProperties);
1245         return VK_SUCCESS;
1246 }
1247
1248 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyProperties2 (VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
1249 {
1250         DE_UNREF(physicalDevice);
1251         DE_UNREF(pQueueFamilyPropertyCount);
1252         DE_UNREF(pQueueFamilyProperties);
1253 }
1254
1255 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMemoryProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
1256 {
1257         DE_UNREF(physicalDevice);
1258         DE_UNREF(pMemoryProperties);
1259 }
1260
1261 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
1262 {
1263         DE_UNREF(physicalDevice);
1264         DE_UNREF(pFormatInfo);
1265         DE_UNREF(pPropertyCount);
1266         DE_UNREF(pProperties);
1267 }
1268
1269 VKAPI_ATTR void VKAPI_CALL trimCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
1270 {
1271         DE_UNREF(device);
1272         DE_UNREF(commandPool);
1273         DE_UNREF(flags);
1274 }
1275
1276 VKAPI_ATTR void VKAPI_CALL getDeviceQueue2 (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
1277 {
1278         DE_UNREF(device);
1279         DE_UNREF(pQueueInfo);
1280         DE_UNREF(pQueue);
1281 }
1282
1283 VKAPI_ATTR void VKAPI_CALL updateDescriptorSetWithTemplate (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
1284 {
1285         DE_UNREF(device);
1286         DE_UNREF(descriptorSet);
1287         DE_UNREF(descriptorUpdateTemplate);
1288         DE_UNREF(pData);
1289 }
1290
1291 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalBufferProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
1292 {
1293         DE_UNREF(physicalDevice);
1294         DE_UNREF(pExternalBufferInfo);
1295         DE_UNREF(pExternalBufferProperties);
1296 }
1297
1298 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalFenceProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
1299 {
1300         DE_UNREF(physicalDevice);
1301         DE_UNREF(pExternalFenceInfo);
1302         DE_UNREF(pExternalFenceProperties);
1303 }
1304
1305 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalSemaphoreProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
1306 {
1307         DE_UNREF(physicalDevice);
1308         DE_UNREF(pExternalSemaphoreInfo);
1309         DE_UNREF(pExternalSemaphoreProperties);
1310 }
1311
1312 VKAPI_ATTR void VKAPI_CALL getDescriptorSetLayoutSupport (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
1313 {
1314         DE_UNREF(device);
1315         DE_UNREF(pCreateInfo);
1316         DE_UNREF(pSupport);
1317 }
1318
1319 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1320 {
1321         DE_UNREF(commandBuffer);
1322         DE_UNREF(buffer);
1323         DE_UNREF(offset);
1324         DE_UNREF(countBuffer);
1325         DE_UNREF(countBufferOffset);
1326         DE_UNREF(maxDrawCount);
1327         DE_UNREF(stride);
1328 }
1329
1330 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1331 {
1332         DE_UNREF(commandBuffer);
1333         DE_UNREF(buffer);
1334         DE_UNREF(offset);
1335         DE_UNREF(countBuffer);
1336         DE_UNREF(countBufferOffset);
1337         DE_UNREF(maxDrawCount);
1338         DE_UNREF(stride);
1339 }
1340
1341 VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass2 (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
1342 {
1343         DE_UNREF(commandBuffer);
1344         DE_UNREF(pRenderPassBegin);
1345         DE_UNREF(pSubpassBeginInfo);
1346 }
1347
1348 VKAPI_ATTR void VKAPI_CALL cmdNextSubpass2 (VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
1349 {
1350         DE_UNREF(commandBuffer);
1351         DE_UNREF(pSubpassBeginInfo);
1352         DE_UNREF(pSubpassEndInfo);
1353 }
1354
1355 VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass2 (VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
1356 {
1357         DE_UNREF(commandBuffer);
1358         DE_UNREF(pSubpassEndInfo);
1359 }
1360
1361 VKAPI_ATTR void VKAPI_CALL resetQueryPool (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
1362 {
1363         DE_UNREF(device);
1364         DE_UNREF(queryPool);
1365         DE_UNREF(firstQuery);
1366         DE_UNREF(queryCount);
1367 }
1368
1369 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreCounterValue (VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
1370 {
1371         DE_UNREF(device);
1372         DE_UNREF(semaphore);
1373         DE_UNREF(pValue);
1374         return VK_SUCCESS;
1375 }
1376
1377 VKAPI_ATTR VkResult VKAPI_CALL waitSemaphores (VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
1378 {
1379         DE_UNREF(device);
1380         DE_UNREF(pWaitInfo);
1381         DE_UNREF(timeout);
1382         return VK_SUCCESS;
1383 }
1384
1385 VKAPI_ATTR VkResult VKAPI_CALL signalSemaphore (VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
1386 {
1387         DE_UNREF(device);
1388         DE_UNREF(pSignalInfo);
1389         return VK_SUCCESS;
1390 }
1391
1392 VKAPI_ATTR VkDeviceAddress VKAPI_CALL getBufferDeviceAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
1393 {
1394         DE_UNREF(device);
1395         DE_UNREF(pInfo);
1396         return VK_SUCCESS;
1397 }
1398
1399 VKAPI_ATTR uint64_t VKAPI_CALL getBufferOpaqueCaptureAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
1400 {
1401         DE_UNREF(device);
1402         DE_UNREF(pInfo);
1403         return VK_SUCCESS;
1404 }
1405
1406 VKAPI_ATTR uint64_t VKAPI_CALL getDeviceMemoryOpaqueCaptureAddress (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
1407 {
1408         DE_UNREF(device);
1409         DE_UNREF(pInfo);
1410         return VK_SUCCESS;
1411 }
1412
1413 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceToolProperties (VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
1414 {
1415         DE_UNREF(physicalDevice);
1416         DE_UNREF(pToolCount);
1417         DE_UNREF(pToolProperties);
1418         return VK_SUCCESS;
1419 }
1420
1421 VKAPI_ATTR VkResult VKAPI_CALL setPrivateData (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
1422 {
1423         DE_UNREF(device);
1424         DE_UNREF(objectType);
1425         DE_UNREF(objectHandle);
1426         DE_UNREF(privateDataSlot);
1427         DE_UNREF(data);
1428         return VK_SUCCESS;
1429 }
1430
1431 VKAPI_ATTR void VKAPI_CALL getPrivateData (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
1432 {
1433         DE_UNREF(device);
1434         DE_UNREF(objectType);
1435         DE_UNREF(objectHandle);
1436         DE_UNREF(privateDataSlot);
1437         DE_UNREF(pData);
1438 }
1439
1440 VKAPI_ATTR void VKAPI_CALL cmdSetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo)
1441 {
1442         DE_UNREF(commandBuffer);
1443         DE_UNREF(event);
1444         DE_UNREF(pDependencyInfo);
1445 }
1446
1447 VKAPI_ATTR void VKAPI_CALL cmdResetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
1448 {
1449         DE_UNREF(commandBuffer);
1450         DE_UNREF(event);
1451         DE_UNREF(stageMask);
1452 }
1453
1454 VKAPI_ATTR void VKAPI_CALL cmdWaitEvents2 (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos)
1455 {
1456         DE_UNREF(commandBuffer);
1457         DE_UNREF(eventCount);
1458         DE_UNREF(pEvents);
1459         DE_UNREF(pDependencyInfos);
1460 }
1461
1462 VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier2 (VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo)
1463 {
1464         DE_UNREF(commandBuffer);
1465         DE_UNREF(pDependencyInfo);
1466 }
1467
1468 VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp2 (VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
1469 {
1470         DE_UNREF(commandBuffer);
1471         DE_UNREF(stage);
1472         DE_UNREF(queryPool);
1473         DE_UNREF(query);
1474 }
1475
1476 VKAPI_ATTR VkResult VKAPI_CALL queueSubmit2 (VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
1477 {
1478         DE_UNREF(queue);
1479         DE_UNREF(submitCount);
1480         DE_UNREF(pSubmits);
1481         DE_UNREF(fence);
1482         return VK_SUCCESS;
1483 }
1484
1485 VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer2 (VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo)
1486 {
1487         DE_UNREF(commandBuffer);
1488         DE_UNREF(pCopyBufferInfo);
1489 }
1490
1491 VKAPI_ATTR void VKAPI_CALL cmdCopyImage2 (VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo)
1492 {
1493         DE_UNREF(commandBuffer);
1494         DE_UNREF(pCopyImageInfo);
1495 }
1496
1497 VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage2 (VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo)
1498 {
1499         DE_UNREF(commandBuffer);
1500         DE_UNREF(pCopyBufferToImageInfo);
1501 }
1502
1503 VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer2 (VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo)
1504 {
1505         DE_UNREF(commandBuffer);
1506         DE_UNREF(pCopyImageToBufferInfo);
1507 }
1508
1509 VKAPI_ATTR void VKAPI_CALL cmdBlitImage2 (VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo)
1510 {
1511         DE_UNREF(commandBuffer);
1512         DE_UNREF(pBlitImageInfo);
1513 }
1514
1515 VKAPI_ATTR void VKAPI_CALL cmdResolveImage2 (VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo)
1516 {
1517         DE_UNREF(commandBuffer);
1518         DE_UNREF(pResolveImageInfo);
1519 }
1520
1521 VKAPI_ATTR void VKAPI_CALL cmdBeginRendering (VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo)
1522 {
1523         DE_UNREF(commandBuffer);
1524         DE_UNREF(pRenderingInfo);
1525 }
1526
1527 VKAPI_ATTR void VKAPI_CALL cmdEndRendering (VkCommandBuffer commandBuffer)
1528 {
1529         DE_UNREF(commandBuffer);
1530 }
1531
1532 VKAPI_ATTR void VKAPI_CALL cmdSetCullMode (VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
1533 {
1534         DE_UNREF(commandBuffer);
1535         DE_UNREF(cullMode);
1536 }
1537
1538 VKAPI_ATTR void VKAPI_CALL cmdSetFrontFace (VkCommandBuffer commandBuffer, VkFrontFace frontFace)
1539 {
1540         DE_UNREF(commandBuffer);
1541         DE_UNREF(frontFace);
1542 }
1543
1544 VKAPI_ATTR void VKAPI_CALL cmdSetPrimitiveTopology (VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
1545 {
1546         DE_UNREF(commandBuffer);
1547         DE_UNREF(primitiveTopology);
1548 }
1549
1550 VKAPI_ATTR void VKAPI_CALL cmdSetViewportWithCount (VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
1551 {
1552         DE_UNREF(commandBuffer);
1553         DE_UNREF(viewportCount);
1554         DE_UNREF(pViewports);
1555 }
1556
1557 VKAPI_ATTR void VKAPI_CALL cmdSetScissorWithCount (VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
1558 {
1559         DE_UNREF(commandBuffer);
1560         DE_UNREF(scissorCount);
1561         DE_UNREF(pScissors);
1562 }
1563
1564 VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers2 (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides)
1565 {
1566         DE_UNREF(commandBuffer);
1567         DE_UNREF(firstBinding);
1568         DE_UNREF(bindingCount);
1569         DE_UNREF(pBuffers);
1570         DE_UNREF(pOffsets);
1571         DE_UNREF(pSizes);
1572         DE_UNREF(pStrides);
1573 }
1574
1575 VKAPI_ATTR void VKAPI_CALL cmdSetDepthTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
1576 {
1577         DE_UNREF(commandBuffer);
1578         DE_UNREF(depthTestEnable);
1579 }
1580
1581 VKAPI_ATTR void VKAPI_CALL cmdSetDepthWriteEnable (VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
1582 {
1583         DE_UNREF(commandBuffer);
1584         DE_UNREF(depthWriteEnable);
1585 }
1586
1587 VKAPI_ATTR void VKAPI_CALL cmdSetDepthCompareOp (VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
1588 {
1589         DE_UNREF(commandBuffer);
1590         DE_UNREF(depthCompareOp);
1591 }
1592
1593 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBoundsTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
1594 {
1595         DE_UNREF(commandBuffer);
1596         DE_UNREF(depthBoundsTestEnable);
1597 }
1598
1599 VKAPI_ATTR void VKAPI_CALL cmdSetStencilTestEnable (VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
1600 {
1601         DE_UNREF(commandBuffer);
1602         DE_UNREF(stencilTestEnable);
1603 }
1604
1605 VKAPI_ATTR void VKAPI_CALL cmdSetStencilOp (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
1606 {
1607         DE_UNREF(commandBuffer);
1608         DE_UNREF(faceMask);
1609         DE_UNREF(failOp);
1610         DE_UNREF(passOp);
1611         DE_UNREF(depthFailOp);
1612         DE_UNREF(compareOp);
1613 }
1614
1615 VKAPI_ATTR void VKAPI_CALL cmdSetRasterizerDiscardEnable (VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
1616 {
1617         DE_UNREF(commandBuffer);
1618         DE_UNREF(rasterizerDiscardEnable);
1619 }
1620
1621 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBiasEnable (VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
1622 {
1623         DE_UNREF(commandBuffer);
1624         DE_UNREF(depthBiasEnable);
1625 }
1626
1627 VKAPI_ATTR void VKAPI_CALL cmdSetPrimitiveRestartEnable (VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
1628 {
1629         DE_UNREF(commandBuffer);
1630         DE_UNREF(primitiveRestartEnable);
1631 }
1632
1633 VKAPI_ATTR void VKAPI_CALL getDeviceBufferMemoryRequirements (VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1634 {
1635         DE_UNREF(device);
1636         DE_UNREF(pInfo);
1637         DE_UNREF(pMemoryRequirements);
1638 }
1639
1640 VKAPI_ATTR void VKAPI_CALL getDeviceImageMemoryRequirements (VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1641 {
1642         DE_UNREF(device);
1643         DE_UNREF(pInfo);
1644         DE_UNREF(pMemoryRequirements);
1645 }
1646
1647 VKAPI_ATTR void VKAPI_CALL getDeviceImageSparseMemoryRequirements (VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1648 {
1649         DE_UNREF(device);
1650         DE_UNREF(pInfo);
1651         DE_UNREF(pSparseMemoryRequirementCount);
1652         DE_UNREF(pSparseMemoryRequirements);
1653 }
1654
1655 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported)
1656 {
1657         DE_UNREF(physicalDevice);
1658         DE_UNREF(queueFamilyIndex);
1659         DE_UNREF(surface);
1660         DE_UNREF(pSupported);
1661         return VK_SUCCESS;
1662 }
1663
1664 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
1665 {
1666         DE_UNREF(physicalDevice);
1667         DE_UNREF(surface);
1668         DE_UNREF(pSurfaceCapabilities);
1669         return VK_SUCCESS;
1670 }
1671
1672 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormatsKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats)
1673 {
1674         DE_UNREF(physicalDevice);
1675         DE_UNREF(surface);
1676         DE_UNREF(pSurfaceFormatCount);
1677         DE_UNREF(pSurfaceFormats);
1678         return VK_SUCCESS;
1679 }
1680
1681 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
1682 {
1683         DE_UNREF(physicalDevice);
1684         DE_UNREF(surface);
1685         DE_UNREF(pPresentModeCount);
1686         DE_UNREF(pPresentModes);
1687         return VK_SUCCESS;
1688 }
1689
1690 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainImagesKHR (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages)
1691 {
1692         DE_UNREF(device);
1693         DE_UNREF(swapchain);
1694         DE_UNREF(pSwapchainImageCount);
1695         DE_UNREF(pSwapchainImages);
1696         return VK_SUCCESS;
1697 }
1698
1699 VKAPI_ATTR VkResult VKAPI_CALL acquireNextImageKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex)
1700 {
1701         DE_UNREF(device);
1702         DE_UNREF(swapchain);
1703         DE_UNREF(timeout);
1704         DE_UNREF(semaphore);
1705         DE_UNREF(fence);
1706         DE_UNREF(pImageIndex);
1707         return VK_SUCCESS;
1708 }
1709
1710 VKAPI_ATTR VkResult VKAPI_CALL queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
1711 {
1712         DE_UNREF(queue);
1713         DE_UNREF(pPresentInfo);
1714         return VK_SUCCESS;
1715 }
1716
1717 VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupPresentCapabilitiesKHR (VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
1718 {
1719         DE_UNREF(device);
1720         DE_UNREF(pDeviceGroupPresentCapabilities);
1721         return VK_SUCCESS;
1722 }
1723
1724 VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupSurfacePresentModesKHR (VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes)
1725 {
1726         DE_UNREF(device);
1727         DE_UNREF(surface);
1728         DE_UNREF(pModes);
1729         return VK_SUCCESS;
1730 }
1731
1732 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDevicePresentRectanglesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects)
1733 {
1734         DE_UNREF(physicalDevice);
1735         DE_UNREF(surface);
1736         DE_UNREF(pRectCount);
1737         DE_UNREF(pRects);
1738         return VK_SUCCESS;
1739 }
1740
1741 VKAPI_ATTR VkResult VKAPI_CALL acquireNextImage2KHR (VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex)
1742 {
1743         DE_UNREF(device);
1744         DE_UNREF(pAcquireInfo);
1745         DE_UNREF(pImageIndex);
1746         return VK_SUCCESS;
1747 }
1748
1749 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPropertiesKHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties)
1750 {
1751         DE_UNREF(physicalDevice);
1752         DE_UNREF(pPropertyCount);
1753         DE_UNREF(pProperties);
1754         return VK_SUCCESS;
1755 }
1756
1757 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlanePropertiesKHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties)
1758 {
1759         DE_UNREF(physicalDevice);
1760         DE_UNREF(pPropertyCount);
1761         DE_UNREF(pProperties);
1762         return VK_SUCCESS;
1763 }
1764
1765 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneSupportedDisplaysKHR (VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays)
1766 {
1767         DE_UNREF(physicalDevice);
1768         DE_UNREF(planeIndex);
1769         DE_UNREF(pDisplayCount);
1770         DE_UNREF(pDisplays);
1771         return VK_SUCCESS;
1772 }
1773
1774 VKAPI_ATTR VkResult VKAPI_CALL getDisplayModePropertiesKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties)
1775 {
1776         DE_UNREF(physicalDevice);
1777         DE_UNREF(display);
1778         DE_UNREF(pPropertyCount);
1779         DE_UNREF(pProperties);
1780         return VK_SUCCESS;
1781 }
1782
1783 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities)
1784 {
1785         DE_UNREF(physicalDevice);
1786         DE_UNREF(mode);
1787         DE_UNREF(planeIndex);
1788         DE_UNREF(pCapabilities);
1789         return VK_SUCCESS;
1790 }
1791
1792 VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd)
1793 {
1794         DE_UNREF(device);
1795         DE_UNREF(pGetFdInfo);
1796         DE_UNREF(pFd);
1797         return VK_SUCCESS;
1798 }
1799
1800 VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdPropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties)
1801 {
1802         DE_UNREF(device);
1803         DE_UNREF(handleType);
1804         DE_UNREF(fd);
1805         DE_UNREF(pMemoryFdProperties);
1806         return VK_SUCCESS;
1807 }
1808
1809 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreFdKHR (VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
1810 {
1811         DE_UNREF(device);
1812         DE_UNREF(pImportSemaphoreFdInfo);
1813         return VK_SUCCESS;
1814 }
1815
1816 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd)
1817 {
1818         DE_UNREF(device);
1819         DE_UNREF(pGetFdInfo);
1820         DE_UNREF(pFd);
1821         return VK_SUCCESS;
1822 }
1823
1824 VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
1825 {
1826         DE_UNREF(commandBuffer);
1827         DE_UNREF(pipelineBindPoint);
1828         DE_UNREF(layout);
1829         DE_UNREF(set);
1830         DE_UNREF(descriptorWriteCount);
1831         DE_UNREF(pDescriptorWrites);
1832 }
1833
1834 VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData)
1835 {
1836         DE_UNREF(commandBuffer);
1837         DE_UNREF(descriptorUpdateTemplate);
1838         DE_UNREF(layout);
1839         DE_UNREF(set);
1840         DE_UNREF(pData);
1841 }
1842
1843 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain)
1844 {
1845         DE_UNREF(device);
1846         DE_UNREF(swapchain);
1847         return VK_SUCCESS;
1848 }
1849
1850 VKAPI_ATTR VkResult VKAPI_CALL importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
1851 {
1852         DE_UNREF(device);
1853         DE_UNREF(pImportFenceFdInfo);
1854         return VK_SUCCESS;
1855 }
1856
1857 VKAPI_ATTR VkResult VKAPI_CALL getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd)
1858 {
1859         DE_UNREF(device);
1860         DE_UNREF(pGetFdInfo);
1861         DE_UNREF(pFd);
1862         return VK_SUCCESS;
1863 }
1864
1865 VKAPI_ATTR VkResult VKAPI_CALL enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions)
1866 {
1867         DE_UNREF(physicalDevice);
1868         DE_UNREF(queueFamilyIndex);
1869         DE_UNREF(pCounterCount);
1870         DE_UNREF(pCounters);
1871         DE_UNREF(pCounterDescriptions);
1872         return VK_SUCCESS;
1873 }
1874
1875 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR (VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses)
1876 {
1877         DE_UNREF(physicalDevice);
1878         DE_UNREF(pPerformanceQueryCreateInfo);
1879         DE_UNREF(pNumPasses);
1880 }
1881
1882 VKAPI_ATTR VkResult VKAPI_CALL acquireProfilingLockKHR (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo)
1883 {
1884         DE_UNREF(device);
1885         DE_UNREF(pInfo);
1886         return VK_SUCCESS;
1887 }
1888
1889 VKAPI_ATTR void VKAPI_CALL releaseProfilingLockKHR (VkDevice device)
1890 {
1891         DE_UNREF(device);
1892 }
1893
1894 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
1895 {
1896         DE_UNREF(physicalDevice);
1897         DE_UNREF(pSurfaceInfo);
1898         DE_UNREF(pSurfaceCapabilities);
1899         return VK_SUCCESS;
1900 }
1901
1902 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats)
1903 {
1904         DE_UNREF(physicalDevice);
1905         DE_UNREF(pSurfaceInfo);
1906         DE_UNREF(pSurfaceFormatCount);
1907         DE_UNREF(pSurfaceFormats);
1908         return VK_SUCCESS;
1909 }
1910
1911 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties)
1912 {
1913         DE_UNREF(physicalDevice);
1914         DE_UNREF(pPropertyCount);
1915         DE_UNREF(pProperties);
1916         return VK_SUCCESS;
1917 }
1918
1919 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlaneProperties2KHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties)
1920 {
1921         DE_UNREF(physicalDevice);
1922         DE_UNREF(pPropertyCount);
1923         DE_UNREF(pProperties);
1924         return VK_SUCCESS;
1925 }
1926
1927 VKAPI_ATTR VkResult VKAPI_CALL getDisplayModeProperties2KHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties)
1928 {
1929         DE_UNREF(physicalDevice);
1930         DE_UNREF(display);
1931         DE_UNREF(pPropertyCount);
1932         DE_UNREF(pProperties);
1933         return VK_SUCCESS;
1934 }
1935
1936 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities)
1937 {
1938         DE_UNREF(physicalDevice);
1939         DE_UNREF(pDisplayPlaneInfo);
1940         DE_UNREF(pCapabilities);
1941         return VK_SUCCESS;
1942 }
1943
1944 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceFragmentShadingRatesKHR (VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
1945 {
1946         DE_UNREF(physicalDevice);
1947         DE_UNREF(pFragmentShadingRateCount);
1948         DE_UNREF(pFragmentShadingRates);
1949         return VK_SUCCESS;
1950 }
1951
1952 VKAPI_ATTR void VKAPI_CALL cmdSetFragmentShadingRateKHR (VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
1953 {
1954         DE_UNREF(commandBuffer);
1955         DE_UNREF(pFragmentSize);
1956         DE_UNREF(combinerOps);
1957 }
1958
1959 VKAPI_ATTR VkResult VKAPI_CALL waitForPresentKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
1960 {
1961         DE_UNREF(device);
1962         DE_UNREF(swapchain);
1963         DE_UNREF(presentId);
1964         DE_UNREF(timeout);
1965         return VK_SUCCESS;
1966 }
1967
1968 VKAPI_ATTR uint32_t VKAPI_CALL getDeferredOperationMaxConcurrencyKHR (VkDevice device, VkDeferredOperationKHR operation)
1969 {
1970         DE_UNREF(device);
1971         DE_UNREF(operation);
1972         return VK_SUCCESS;
1973 }
1974
1975 VKAPI_ATTR VkResult VKAPI_CALL getDeferredOperationResultKHR (VkDevice device, VkDeferredOperationKHR operation)
1976 {
1977         DE_UNREF(device);
1978         DE_UNREF(operation);
1979         return VK_SUCCESS;
1980 }
1981
1982 VKAPI_ATTR VkResult VKAPI_CALL deferredOperationJoinKHR (VkDevice device, VkDeferredOperationKHR operation)
1983 {
1984         DE_UNREF(device);
1985         DE_UNREF(operation);
1986         return VK_SUCCESS;
1987 }
1988
1989 VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties)
1990 {
1991         DE_UNREF(device);
1992         DE_UNREF(pPipelineInfo);
1993         DE_UNREF(pExecutableCount);
1994         DE_UNREF(pProperties);
1995         return VK_SUCCESS;
1996 }
1997
1998 VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics)
1999 {
2000         DE_UNREF(device);
2001         DE_UNREF(pExecutableInfo);
2002         DE_UNREF(pStatisticCount);
2003         DE_UNREF(pStatistics);
2004         return VK_SUCCESS;
2005 }
2006
2007 VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
2008 {
2009         DE_UNREF(device);
2010         DE_UNREF(pExecutableInfo);
2011         DE_UNREF(pInternalRepresentationCount);
2012         DE_UNREF(pInternalRepresentations);
2013         return VK_SUCCESS;
2014 }
2015
2016 VKAPI_ATTR void VKAPI_CALL cmdWriteBufferMarker2AMD (VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
2017 {
2018         DE_UNREF(commandBuffer);
2019         DE_UNREF(stage);
2020         DE_UNREF(dstBuffer);
2021         DE_UNREF(dstOffset);
2022         DE_UNREF(marker);
2023 }
2024
2025 VKAPI_ATTR void VKAPI_CALL getQueueCheckpointData2NV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData)
2026 {
2027         DE_UNREF(queue);
2028         DE_UNREF(pCheckpointDataCount);
2029         DE_UNREF(pCheckpointData);
2030 }
2031
2032 VKAPI_ATTR void VKAPI_CALL cmdTraceRaysIndirect2KHR (VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
2033 {
2034         DE_UNREF(commandBuffer);
2035         DE_UNREF(indirectDeviceAddress);
2036 }
2037
2038 VKAPI_ATTR void VKAPI_CALL debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage)
2039 {
2040         DE_UNREF(instance);
2041         DE_UNREF(flags);
2042         DE_UNREF(objectType);
2043         DE_UNREF(object);
2044         DE_UNREF(location);
2045         DE_UNREF(messageCode);
2046         DE_UNREF(pLayerPrefix);
2047         DE_UNREF(pMessage);
2048 }
2049
2050 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
2051 {
2052         DE_UNREF(device);
2053         DE_UNREF(pTagInfo);
2054         return VK_SUCCESS;
2055 }
2056
2057 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
2058 {
2059         DE_UNREF(device);
2060         DE_UNREF(pNameInfo);
2061         return VK_SUCCESS;
2062 }
2063
2064 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
2065 {
2066         DE_UNREF(commandBuffer);
2067         DE_UNREF(pMarkerInfo);
2068 }
2069
2070 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer)
2071 {
2072         DE_UNREF(commandBuffer);
2073 }
2074
2075 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
2076 {
2077         DE_UNREF(commandBuffer);
2078         DE_UNREF(pMarkerInfo);
2079 }
2080
2081 VKAPI_ATTR void VKAPI_CALL cmdBindTransformFeedbackBuffersEXT (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
2082 {
2083         DE_UNREF(commandBuffer);
2084         DE_UNREF(firstBinding);
2085         DE_UNREF(bindingCount);
2086         DE_UNREF(pBuffers);
2087         DE_UNREF(pOffsets);
2088         DE_UNREF(pSizes);
2089 }
2090
2091 VKAPI_ATTR void VKAPI_CALL cmdBeginTransformFeedbackEXT (VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
2092 {
2093         DE_UNREF(commandBuffer);
2094         DE_UNREF(firstCounterBuffer);
2095         DE_UNREF(counterBufferCount);
2096         DE_UNREF(pCounterBuffers);
2097         DE_UNREF(pCounterBufferOffsets);
2098 }
2099
2100 VKAPI_ATTR void VKAPI_CALL cmdEndTransformFeedbackEXT (VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
2101 {
2102         DE_UNREF(commandBuffer);
2103         DE_UNREF(firstCounterBuffer);
2104         DE_UNREF(counterBufferCount);
2105         DE_UNREF(pCounterBuffers);
2106         DE_UNREF(pCounterBufferOffsets);
2107 }
2108
2109 VKAPI_ATTR void VKAPI_CALL cmdBeginQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
2110 {
2111         DE_UNREF(commandBuffer);
2112         DE_UNREF(queryPool);
2113         DE_UNREF(query);
2114         DE_UNREF(flags);
2115         DE_UNREF(index);
2116 }
2117
2118 VKAPI_ATTR void VKAPI_CALL cmdEndQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
2119 {
2120         DE_UNREF(commandBuffer);
2121         DE_UNREF(queryPool);
2122         DE_UNREF(query);
2123         DE_UNREF(index);
2124 }
2125
2126 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectByteCountEXT (VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
2127 {
2128         DE_UNREF(commandBuffer);
2129         DE_UNREF(instanceCount);
2130         DE_UNREF(firstInstance);
2131         DE_UNREF(counterBuffer);
2132         DE_UNREF(counterBufferOffset);
2133         DE_UNREF(counterOffset);
2134         DE_UNREF(vertexStride);
2135 }
2136
2137 VKAPI_ATTR void VKAPI_CALL cmdCuLaunchKernelNVX (VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo)
2138 {
2139         DE_UNREF(commandBuffer);
2140         DE_UNREF(pLaunchInfo);
2141 }
2142
2143 VKAPI_ATTR uint32_t VKAPI_CALL getImageViewHandleNVX (VkDevice device, const VkImageViewHandleInfoNVX* pInfo)
2144 {
2145         DE_UNREF(device);
2146         DE_UNREF(pInfo);
2147         return VK_SUCCESS;
2148 }
2149
2150 VKAPI_ATTR VkResult VKAPI_CALL getImageViewAddressNVX (VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties)
2151 {
2152         DE_UNREF(device);
2153         DE_UNREF(imageView);
2154         DE_UNREF(pProperties);
2155         return VK_SUCCESS;
2156 }
2157
2158 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
2159 {
2160         DE_UNREF(commandBuffer);
2161         DE_UNREF(buffer);
2162         DE_UNREF(offset);
2163         DE_UNREF(countBuffer);
2164         DE_UNREF(countBufferOffset);
2165         DE_UNREF(maxDrawCount);
2166         DE_UNREF(stride);
2167 }
2168
2169 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
2170 {
2171         DE_UNREF(commandBuffer);
2172         DE_UNREF(buffer);
2173         DE_UNREF(offset);
2174         DE_UNREF(countBuffer);
2175         DE_UNREF(countBufferOffset);
2176         DE_UNREF(maxDrawCount);
2177         DE_UNREF(stride);
2178 }
2179
2180 VKAPI_ATTR VkResult VKAPI_CALL getShaderInfoAMD (VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo)
2181 {
2182         DE_UNREF(device);
2183         DE_UNREF(pipeline);
2184         DE_UNREF(shaderStage);
2185         DE_UNREF(infoType);
2186         DE_UNREF(pInfoSize);
2187         DE_UNREF(pInfo);
2188         return VK_SUCCESS;
2189 }
2190
2191 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
2192 {
2193         DE_UNREF(physicalDevice);
2194         DE_UNREF(format);
2195         DE_UNREF(type);
2196         DE_UNREF(tiling);
2197         DE_UNREF(usage);
2198         DE_UNREF(flags);
2199         DE_UNREF(externalHandleType);
2200         DE_UNREF(pExternalImageFormatProperties);
2201         return VK_SUCCESS;
2202 }
2203
2204 VKAPI_ATTR void VKAPI_CALL cmdBeginConditionalRenderingEXT (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
2205 {
2206         DE_UNREF(commandBuffer);
2207         DE_UNREF(pConditionalRenderingBegin);
2208 }
2209
2210 VKAPI_ATTR void VKAPI_CALL cmdEndConditionalRenderingEXT (VkCommandBuffer commandBuffer)
2211 {
2212         DE_UNREF(commandBuffer);
2213 }
2214
2215 VKAPI_ATTR void VKAPI_CALL cmdSetViewportWScalingNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings)
2216 {
2217         DE_UNREF(commandBuffer);
2218         DE_UNREF(firstViewport);
2219         DE_UNREF(viewportCount);
2220         DE_UNREF(pViewportWScalings);
2221 }
2222
2223 VKAPI_ATTR VkResult VKAPI_CALL releaseDisplayEXT (VkPhysicalDevice physicalDevice, VkDisplayKHR display)
2224 {
2225         DE_UNREF(physicalDevice);
2226         DE_UNREF(display);
2227         return VK_SUCCESS;
2228 }
2229
2230 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2EXT (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
2231 {
2232         DE_UNREF(physicalDevice);
2233         DE_UNREF(surface);
2234         DE_UNREF(pSurfaceCapabilities);
2235         return VK_SUCCESS;
2236 }
2237
2238 VKAPI_ATTR VkResult VKAPI_CALL displayPowerControlEXT (VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
2239 {
2240         DE_UNREF(device);
2241         DE_UNREF(display);
2242         DE_UNREF(pDisplayPowerInfo);
2243         return VK_SUCCESS;
2244 }
2245
2246 VKAPI_ATTR VkResult VKAPI_CALL registerDeviceEventEXT (VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
2247 {
2248         DE_UNREF(device);
2249         DE_UNREF(pDeviceEventInfo);
2250         DE_UNREF(pAllocator);
2251         DE_UNREF(pFence);
2252         return VK_SUCCESS;
2253 }
2254
2255 VKAPI_ATTR VkResult VKAPI_CALL registerDisplayEventEXT (VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
2256 {
2257         DE_UNREF(device);
2258         DE_UNREF(display);
2259         DE_UNREF(pDisplayEventInfo);
2260         DE_UNREF(pAllocator);
2261         DE_UNREF(pFence);
2262         return VK_SUCCESS;
2263 }
2264
2265 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainCounterEXT (VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue)
2266 {
2267         DE_UNREF(device);
2268         DE_UNREF(swapchain);
2269         DE_UNREF(counter);
2270         DE_UNREF(pCounterValue);
2271         return VK_SUCCESS;
2272 }
2273
2274 VKAPI_ATTR VkResult VKAPI_CALL getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
2275 {
2276         DE_UNREF(device);
2277         DE_UNREF(swapchain);
2278         DE_UNREF(pDisplayTimingProperties);
2279         return VK_SUCCESS;
2280 }
2281
2282 VKAPI_ATTR VkResult VKAPI_CALL getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings)
2283 {
2284         DE_UNREF(device);
2285         DE_UNREF(swapchain);
2286         DE_UNREF(pPresentationTimingCount);
2287         DE_UNREF(pPresentationTimings);
2288         return VK_SUCCESS;
2289 }
2290
2291 VKAPI_ATTR void VKAPI_CALL cmdSetDiscardRectangleEXT (VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles)
2292 {
2293         DE_UNREF(commandBuffer);
2294         DE_UNREF(firstDiscardRectangle);
2295         DE_UNREF(discardRectangleCount);
2296         DE_UNREF(pDiscardRectangles);
2297 }
2298
2299 VKAPI_ATTR void VKAPI_CALL setHdrMetadataEXT (VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata)
2300 {
2301         DE_UNREF(device);
2302         DE_UNREF(swapchainCount);
2303         DE_UNREF(pSwapchains);
2304         DE_UNREF(pMetadata);
2305 }
2306
2307 VKAPI_ATTR VkResult VKAPI_CALL setDebugUtilsObjectNameEXT (VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
2308 {
2309         DE_UNREF(device);
2310         DE_UNREF(pNameInfo);
2311         return VK_SUCCESS;
2312 }
2313
2314 VKAPI_ATTR VkResult VKAPI_CALL setDebugUtilsObjectTagEXT (VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
2315 {
2316         DE_UNREF(device);
2317         DE_UNREF(pTagInfo);
2318         return VK_SUCCESS;
2319 }
2320
2321 VKAPI_ATTR void VKAPI_CALL queueBeginDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
2322 {
2323         DE_UNREF(queue);
2324         DE_UNREF(pLabelInfo);
2325 }
2326
2327 VKAPI_ATTR void VKAPI_CALL queueEndDebugUtilsLabelEXT (VkQueue queue)
2328 {
2329         DE_UNREF(queue);
2330 }
2331
2332 VKAPI_ATTR void VKAPI_CALL queueInsertDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
2333 {
2334         DE_UNREF(queue);
2335         DE_UNREF(pLabelInfo);
2336 }
2337
2338 VKAPI_ATTR void VKAPI_CALL cmdBeginDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
2339 {
2340         DE_UNREF(commandBuffer);
2341         DE_UNREF(pLabelInfo);
2342 }
2343
2344 VKAPI_ATTR void VKAPI_CALL cmdEndDebugUtilsLabelEXT (VkCommandBuffer commandBuffer)
2345 {
2346         DE_UNREF(commandBuffer);
2347 }
2348
2349 VKAPI_ATTR void VKAPI_CALL cmdInsertDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
2350 {
2351         DE_UNREF(commandBuffer);
2352         DE_UNREF(pLabelInfo);
2353 }
2354
2355 VKAPI_ATTR void VKAPI_CALL submitDebugUtilsMessageEXT (VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
2356 {
2357         DE_UNREF(instance);
2358         DE_UNREF(messageSeverity);
2359         DE_UNREF(messageTypes);
2360         DE_UNREF(pCallbackData);
2361 }
2362
2363 VKAPI_ATTR void VKAPI_CALL cmdSetSampleLocationsEXT (VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
2364 {
2365         DE_UNREF(commandBuffer);
2366         DE_UNREF(pSampleLocationsInfo);
2367 }
2368
2369 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMultisamplePropertiesEXT (VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties)
2370 {
2371         DE_UNREF(physicalDevice);
2372         DE_UNREF(samples);
2373         DE_UNREF(pMultisampleProperties);
2374 }
2375
2376 VKAPI_ATTR VkResult VKAPI_CALL getImageDrmFormatModifierPropertiesEXT (VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2377 {
2378         DE_UNREF(device);
2379         DE_UNREF(image);
2380         DE_UNREF(pProperties);
2381         return VK_SUCCESS;
2382 }
2383
2384 VKAPI_ATTR VkResult VKAPI_CALL mergeValidationCachesEXT (VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches)
2385 {
2386         DE_UNREF(device);
2387         DE_UNREF(dstCache);
2388         DE_UNREF(srcCacheCount);
2389         DE_UNREF(pSrcCaches);
2390         return VK_SUCCESS;
2391 }
2392
2393 VKAPI_ATTR VkResult VKAPI_CALL getValidationCacheDataEXT (VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData)
2394 {
2395         DE_UNREF(device);
2396         DE_UNREF(validationCache);
2397         DE_UNREF(pDataSize);
2398         DE_UNREF(pData);
2399         return VK_SUCCESS;
2400 }
2401
2402 VKAPI_ATTR void VKAPI_CALL cmdBindShadingRateImageNV (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
2403 {
2404         DE_UNREF(commandBuffer);
2405         DE_UNREF(imageView);
2406         DE_UNREF(imageLayout);
2407 }
2408
2409 VKAPI_ATTR void VKAPI_CALL cmdSetViewportShadingRatePaletteNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes)
2410 {
2411         DE_UNREF(commandBuffer);
2412         DE_UNREF(firstViewport);
2413         DE_UNREF(viewportCount);
2414         DE_UNREF(pShadingRatePalettes);
2415 }
2416
2417 VKAPI_ATTR void VKAPI_CALL cmdSetCoarseSampleOrderNV (VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders)
2418 {
2419         DE_UNREF(commandBuffer);
2420         DE_UNREF(sampleOrderType);
2421         DE_UNREF(customSampleOrderCount);
2422         DE_UNREF(pCustomSampleOrders);
2423 }
2424
2425 VKAPI_ATTR void VKAPI_CALL getAccelerationStructureMemoryRequirementsNV (VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
2426 {
2427         DE_UNREF(device);
2428         DE_UNREF(pInfo);
2429         DE_UNREF(pMemoryRequirements);
2430 }
2431
2432 VKAPI_ATTR VkResult VKAPI_CALL bindAccelerationStructureMemoryNV (VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos)
2433 {
2434         DE_UNREF(device);
2435         DE_UNREF(bindInfoCount);
2436         DE_UNREF(pBindInfos);
2437         return VK_SUCCESS;
2438 }
2439
2440 VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructureNV (VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
2441 {
2442         DE_UNREF(commandBuffer);
2443         DE_UNREF(pInfo);
2444         DE_UNREF(instanceData);
2445         DE_UNREF(instanceOffset);
2446         DE_UNREF(update);
2447         DE_UNREF(dst);
2448         DE_UNREF(src);
2449         DE_UNREF(scratch);
2450         DE_UNREF(scratchOffset);
2451 }
2452
2453 VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureNV (VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
2454 {
2455         DE_UNREF(commandBuffer);
2456         DE_UNREF(dst);
2457         DE_UNREF(src);
2458         DE_UNREF(mode);
2459 }
2460
2461 VKAPI_ATTR void VKAPI_CALL cmdTraceRaysNV (VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
2462 {
2463         DE_UNREF(commandBuffer);
2464         DE_UNREF(raygenShaderBindingTableBuffer);
2465         DE_UNREF(raygenShaderBindingOffset);
2466         DE_UNREF(missShaderBindingTableBuffer);
2467         DE_UNREF(missShaderBindingOffset);
2468         DE_UNREF(missShaderBindingStride);
2469         DE_UNREF(hitShaderBindingTableBuffer);
2470         DE_UNREF(hitShaderBindingOffset);
2471         DE_UNREF(hitShaderBindingStride);
2472         DE_UNREF(callableShaderBindingTableBuffer);
2473         DE_UNREF(callableShaderBindingOffset);
2474         DE_UNREF(callableShaderBindingStride);
2475         DE_UNREF(width);
2476         DE_UNREF(height);
2477         DE_UNREF(depth);
2478 }
2479
2480 VKAPI_ATTR VkResult VKAPI_CALL getRayTracingShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
2481 {
2482         DE_UNREF(device);
2483         DE_UNREF(pipeline);
2484         DE_UNREF(firstGroup);
2485         DE_UNREF(groupCount);
2486         DE_UNREF(dataSize);
2487         DE_UNREF(pData);
2488         return VK_SUCCESS;
2489 }
2490
2491 VKAPI_ATTR VkResult VKAPI_CALL getRayTracingShaderGroupHandlesNV (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
2492 {
2493         DE_UNREF(device);
2494         DE_UNREF(pipeline);
2495         DE_UNREF(firstGroup);
2496         DE_UNREF(groupCount);
2497         DE_UNREF(dataSize);
2498         DE_UNREF(pData);
2499         return VK_SUCCESS;
2500 }
2501
2502 VKAPI_ATTR VkResult VKAPI_CALL getAccelerationStructureHandleNV (VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData)
2503 {
2504         DE_UNREF(device);
2505         DE_UNREF(accelerationStructure);
2506         DE_UNREF(dataSize);
2507         DE_UNREF(pData);
2508         return VK_SUCCESS;
2509 }
2510
2511 VKAPI_ATTR void VKAPI_CALL cmdWriteAccelerationStructuresPropertiesNV (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2512 {
2513         DE_UNREF(commandBuffer);
2514         DE_UNREF(accelerationStructureCount);
2515         DE_UNREF(pAccelerationStructures);
2516         DE_UNREF(queryType);
2517         DE_UNREF(queryPool);
2518         DE_UNREF(firstQuery);
2519 }
2520
2521 VKAPI_ATTR VkResult VKAPI_CALL compileDeferredNV (VkDevice device, VkPipeline pipeline, uint32_t shader)
2522 {
2523         DE_UNREF(device);
2524         DE_UNREF(pipeline);
2525         DE_UNREF(shader);
2526         return VK_SUCCESS;
2527 }
2528
2529 VKAPI_ATTR VkResult VKAPI_CALL getMemoryHostPointerPropertiesEXT (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
2530 {
2531         DE_UNREF(device);
2532         DE_UNREF(handleType);
2533         DE_UNREF(pHostPointer);
2534         DE_UNREF(pMemoryHostPointerProperties);
2535         return VK_SUCCESS;
2536 }
2537
2538 VKAPI_ATTR void VKAPI_CALL cmdWriteBufferMarkerAMD (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
2539 {
2540         DE_UNREF(commandBuffer);
2541         DE_UNREF(pipelineStage);
2542         DE_UNREF(dstBuffer);
2543         DE_UNREF(dstOffset);
2544         DE_UNREF(marker);
2545 }
2546
2547 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceCalibrateableTimeDomainsEXT (VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
2548 {
2549         DE_UNREF(physicalDevice);
2550         DE_UNREF(pTimeDomainCount);
2551         DE_UNREF(pTimeDomains);
2552         return VK_SUCCESS;
2553 }
2554
2555 VKAPI_ATTR VkResult VKAPI_CALL getCalibratedTimestampsEXT (VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
2556 {
2557         DE_UNREF(device);
2558         DE_UNREF(timestampCount);
2559         DE_UNREF(pTimestampInfos);
2560         DE_UNREF(pTimestamps);
2561         DE_UNREF(pMaxDeviation);
2562         return VK_SUCCESS;
2563 }
2564
2565 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksNV (VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
2566 {
2567         DE_UNREF(commandBuffer);
2568         DE_UNREF(taskCount);
2569         DE_UNREF(firstTask);
2570 }
2571
2572 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
2573 {
2574         DE_UNREF(commandBuffer);
2575         DE_UNREF(buffer);
2576         DE_UNREF(offset);
2577         DE_UNREF(drawCount);
2578         DE_UNREF(stride);
2579 }
2580
2581 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectCountNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
2582 {
2583         DE_UNREF(commandBuffer);
2584         DE_UNREF(buffer);
2585         DE_UNREF(offset);
2586         DE_UNREF(countBuffer);
2587         DE_UNREF(countBufferOffset);
2588         DE_UNREF(maxDrawCount);
2589         DE_UNREF(stride);
2590 }
2591
2592 VKAPI_ATTR void VKAPI_CALL cmdSetExclusiveScissorNV (VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors)
2593 {
2594         DE_UNREF(commandBuffer);
2595         DE_UNREF(firstExclusiveScissor);
2596         DE_UNREF(exclusiveScissorCount);
2597         DE_UNREF(pExclusiveScissors);
2598 }
2599
2600 VKAPI_ATTR void VKAPI_CALL cmdSetCheckpointNV (VkCommandBuffer commandBuffer, const void* pCheckpointMarker)
2601 {
2602         DE_UNREF(commandBuffer);
2603         DE_UNREF(pCheckpointMarker);
2604 }
2605
2606 VKAPI_ATTR void VKAPI_CALL getQueueCheckpointDataNV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData)
2607 {
2608         DE_UNREF(queue);
2609         DE_UNREF(pCheckpointDataCount);
2610         DE_UNREF(pCheckpointData);
2611 }
2612
2613 VKAPI_ATTR VkResult VKAPI_CALL initializePerformanceApiINTEL (VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo)
2614 {
2615         DE_UNREF(device);
2616         DE_UNREF(pInitializeInfo);
2617         return VK_SUCCESS;
2618 }
2619
2620 VKAPI_ATTR void VKAPI_CALL uninitializePerformanceApiINTEL (VkDevice device)
2621 {
2622         DE_UNREF(device);
2623 }
2624
2625 VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo)
2626 {
2627         DE_UNREF(commandBuffer);
2628         DE_UNREF(pMarkerInfo);
2629         return VK_SUCCESS;
2630 }
2631
2632 VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceStreamMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo)
2633 {
2634         DE_UNREF(commandBuffer);
2635         DE_UNREF(pMarkerInfo);
2636         return VK_SUCCESS;
2637 }
2638
2639 VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceOverrideINTEL (VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo)
2640 {
2641         DE_UNREF(commandBuffer);
2642         DE_UNREF(pOverrideInfo);
2643         return VK_SUCCESS;
2644 }
2645
2646 VKAPI_ATTR VkResult VKAPI_CALL acquirePerformanceConfigurationINTEL (VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration)
2647 {
2648         DE_UNREF(device);
2649         DE_UNREF(pAcquireInfo);
2650         DE_UNREF(pConfiguration);
2651         return VK_SUCCESS;
2652 }
2653
2654 VKAPI_ATTR VkResult VKAPI_CALL releasePerformanceConfigurationINTEL (VkDevice device, VkPerformanceConfigurationINTEL configuration)
2655 {
2656         DE_UNREF(device);
2657         DE_UNREF(configuration);
2658         return VK_SUCCESS;
2659 }
2660
2661 VKAPI_ATTR VkResult VKAPI_CALL queueSetPerformanceConfigurationINTEL (VkQueue queue, VkPerformanceConfigurationINTEL configuration)
2662 {
2663         DE_UNREF(queue);
2664         DE_UNREF(configuration);
2665         return VK_SUCCESS;
2666 }
2667
2668 VKAPI_ATTR VkResult VKAPI_CALL getPerformanceParameterINTEL (VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue)
2669 {
2670         DE_UNREF(device);
2671         DE_UNREF(parameter);
2672         DE_UNREF(pValue);
2673         return VK_SUCCESS;
2674 }
2675
2676 VKAPI_ATTR void VKAPI_CALL setLocalDimmingAMD (VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
2677 {
2678         DE_UNREF(device);
2679         DE_UNREF(swapChain);
2680         DE_UNREF(localDimmingEnable);
2681 }
2682
2683 VKAPI_ATTR VkDeviceAddress VKAPI_CALL getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
2684 {
2685         DE_UNREF(device);
2686         DE_UNREF(pInfo);
2687         return VK_SUCCESS;
2688 }
2689
2690 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceCooperativeMatrixPropertiesNV (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties)
2691 {
2692         DE_UNREF(physicalDevice);
2693         DE_UNREF(pPropertyCount);
2694         DE_UNREF(pProperties);
2695         return VK_SUCCESS;
2696 }
2697
2698 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV (VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations)
2699 {
2700         DE_UNREF(physicalDevice);
2701         DE_UNREF(pCombinationCount);
2702         DE_UNREF(pCombinations);
2703         return VK_SUCCESS;
2704 }
2705
2706 VKAPI_ATTR void VKAPI_CALL cmdSetLineStippleEXT (VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
2707 {
2708         DE_UNREF(commandBuffer);
2709         DE_UNREF(lineStippleFactor);
2710         DE_UNREF(lineStipplePattern);
2711 }
2712
2713 VKAPI_ATTR void VKAPI_CALL getGeneratedCommandsMemoryRequirementsNV (VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2714 {
2715         DE_UNREF(device);
2716         DE_UNREF(pInfo);
2717         DE_UNREF(pMemoryRequirements);
2718 }
2719
2720 VKAPI_ATTR void VKAPI_CALL cmdPreprocessGeneratedCommandsNV (VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
2721 {
2722         DE_UNREF(commandBuffer);
2723         DE_UNREF(pGeneratedCommandsInfo);
2724 }
2725
2726 VKAPI_ATTR void VKAPI_CALL cmdExecuteGeneratedCommandsNV (VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
2727 {
2728         DE_UNREF(commandBuffer);
2729         DE_UNREF(isPreprocessed);
2730         DE_UNREF(pGeneratedCommandsInfo);
2731 }
2732
2733 VKAPI_ATTR void VKAPI_CALL cmdBindPipelineShaderGroupNV (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
2734 {
2735         DE_UNREF(commandBuffer);
2736         DE_UNREF(pipelineBindPoint);
2737         DE_UNREF(pipeline);
2738         DE_UNREF(groupIndex);
2739 }
2740
2741 VKAPI_ATTR VkResult VKAPI_CALL acquireDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
2742 {
2743         DE_UNREF(physicalDevice);
2744         DE_UNREF(drmFd);
2745         DE_UNREF(display);
2746         return VK_SUCCESS;
2747 }
2748
2749 VKAPI_ATTR VkResult VKAPI_CALL getDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display)
2750 {
2751         DE_UNREF(physicalDevice);
2752         DE_UNREF(drmFd);
2753         DE_UNREF(connectorId);
2754         DE_UNREF(display);
2755         return VK_SUCCESS;
2756 }
2757
2758 VKAPI_ATTR void VKAPI_CALL cmdSetFragmentShadingRateEnumNV (VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
2759 {
2760         DE_UNREF(commandBuffer);
2761         DE_UNREF(shadingRate);
2762         DE_UNREF(combinerOps);
2763 }
2764
2765 VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout2EXT (VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout)
2766 {
2767         DE_UNREF(device);
2768         DE_UNREF(image);
2769         DE_UNREF(pSubresource);
2770         DE_UNREF(pLayout);
2771 }
2772
2773 VKAPI_ATTR VkResult VKAPI_CALL acquireWinrtDisplayNV (VkPhysicalDevice physicalDevice, VkDisplayKHR display)
2774 {
2775         DE_UNREF(physicalDevice);
2776         DE_UNREF(display);
2777         return VK_SUCCESS;
2778 }
2779
2780 VKAPI_ATTR VkResult VKAPI_CALL getWinrtDisplayNV (VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay)
2781 {
2782         DE_UNREF(physicalDevice);
2783         DE_UNREF(deviceRelativeId);
2784         DE_UNREF(pDisplay);
2785         return VK_SUCCESS;
2786 }
2787
2788 VKAPI_ATTR void VKAPI_CALL cmdSetVertexInputEXT (VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions)
2789 {
2790         DE_UNREF(commandBuffer);
2791         DE_UNREF(vertexBindingDescriptionCount);
2792         DE_UNREF(pVertexBindingDescriptions);
2793         DE_UNREF(vertexAttributeDescriptionCount);
2794         DE_UNREF(pVertexAttributeDescriptions);
2795 }
2796
2797 VKAPI_ATTR VkResult VKAPI_CALL getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI (VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize)
2798 {
2799         DE_UNREF(device);
2800         DE_UNREF(renderpass);
2801         DE_UNREF(pMaxWorkgroupSize);
2802         return VK_SUCCESS;
2803 }
2804
2805 VKAPI_ATTR void VKAPI_CALL cmdSubpassShadingHUAWEI (VkCommandBuffer commandBuffer)
2806 {
2807         DE_UNREF(commandBuffer);
2808 }
2809
2810 VKAPI_ATTR void VKAPI_CALL cmdBindInvocationMaskHUAWEI (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
2811 {
2812         DE_UNREF(commandBuffer);
2813         DE_UNREF(imageView);
2814         DE_UNREF(imageLayout);
2815 }
2816
2817 VKAPI_ATTR VkResult VKAPI_CALL getMemoryRemoteAddressNV (VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress)
2818 {
2819         DE_UNREF(device);
2820         DE_UNREF(pMemoryGetRemoteAddressInfo);
2821         DE_UNREF(pAddress);
2822         return VK_SUCCESS;
2823 }
2824
2825 VKAPI_ATTR VkResult VKAPI_CALL getPipelinePropertiesEXT (VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties)
2826 {
2827         DE_UNREF(device);
2828         DE_UNREF(pPipelineInfo);
2829         DE_UNREF(pPipelineProperties);
2830         return VK_SUCCESS;
2831 }
2832
2833 VKAPI_ATTR void VKAPI_CALL cmdSetPatchControlPointsEXT (VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
2834 {
2835         DE_UNREF(commandBuffer);
2836         DE_UNREF(patchControlPoints);
2837 }
2838
2839 VKAPI_ATTR void VKAPI_CALL cmdSetLogicOpEXT (VkCommandBuffer commandBuffer, VkLogicOp logicOp)
2840 {
2841         DE_UNREF(commandBuffer);
2842         DE_UNREF(logicOp);
2843 }
2844
2845 VKAPI_ATTR void VKAPI_CALL cmdSetColorWriteEnableEXT (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables)
2846 {
2847         DE_UNREF(commandBuffer);
2848         DE_UNREF(attachmentCount);
2849         DE_UNREF(pColorWriteEnables);
2850 }
2851
2852 VKAPI_ATTR void VKAPI_CALL cmdDrawMultiEXT (VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
2853 {
2854         DE_UNREF(commandBuffer);
2855         DE_UNREF(drawCount);
2856         DE_UNREF(pVertexInfo);
2857         DE_UNREF(instanceCount);
2858         DE_UNREF(firstInstance);
2859         DE_UNREF(stride);
2860 }
2861
2862 VKAPI_ATTR void VKAPI_CALL cmdDrawMultiIndexedEXT (VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset)
2863 {
2864         DE_UNREF(commandBuffer);
2865         DE_UNREF(drawCount);
2866         DE_UNREF(pIndexInfo);
2867         DE_UNREF(instanceCount);
2868         DE_UNREF(firstInstance);
2869         DE_UNREF(stride);
2870         DE_UNREF(pVertexOffset);
2871 }
2872
2873 VKAPI_ATTR void VKAPI_CALL setDeviceMemoryPriorityEXT (VkDevice device, VkDeviceMemory memory, float priority)
2874 {
2875         DE_UNREF(device);
2876         DE_UNREF(memory);
2877         DE_UNREF(priority);
2878 }
2879
2880 VKAPI_ATTR void VKAPI_CALL getDescriptorSetLayoutHostMappingInfoVALVE (VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping)
2881 {
2882         DE_UNREF(device);
2883         DE_UNREF(pBindingReference);
2884         DE_UNREF(pHostMapping);
2885 }
2886
2887 VKAPI_ATTR void VKAPI_CALL getDescriptorSetHostMappingVALVE (VkDevice device, VkDescriptorSet descriptorSet, void** ppData)
2888 {
2889         DE_UNREF(device);
2890         DE_UNREF(descriptorSet);
2891         DE_UNREF(ppData);
2892 }
2893
2894 VKAPI_ATTR void VKAPI_CALL getShaderModuleIdentifierEXT (VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier)
2895 {
2896         DE_UNREF(device);
2897         DE_UNREF(shaderModule);
2898         DE_UNREF(pIdentifier);
2899 }
2900
2901 VKAPI_ATTR void VKAPI_CALL getShaderModuleCreateInfoIdentifierEXT (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier)
2902 {
2903         DE_UNREF(device);
2904         DE_UNREF(pCreateInfo);
2905         DE_UNREF(pIdentifier);
2906 }
2907
2908 VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructuresKHR (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
2909 {
2910         DE_UNREF(commandBuffer);
2911         DE_UNREF(infoCount);
2912         DE_UNREF(pInfos);
2913         DE_UNREF(ppBuildRangeInfos);
2914 }
2915
2916 VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructuresIndirectKHR (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts)
2917 {
2918         DE_UNREF(commandBuffer);
2919         DE_UNREF(infoCount);
2920         DE_UNREF(pInfos);
2921         DE_UNREF(pIndirectDeviceAddresses);
2922         DE_UNREF(pIndirectStrides);
2923         DE_UNREF(ppMaxPrimitiveCounts);
2924 }
2925
2926 VKAPI_ATTR VkResult VKAPI_CALL buildAccelerationStructuresKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
2927 {
2928         DE_UNREF(device);
2929         DE_UNREF(deferredOperation);
2930         DE_UNREF(infoCount);
2931         DE_UNREF(pInfos);
2932         DE_UNREF(ppBuildRangeInfos);
2933         return VK_SUCCESS;
2934 }
2935
2936 VKAPI_ATTR VkResult VKAPI_CALL copyAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo)
2937 {
2938         DE_UNREF(device);
2939         DE_UNREF(deferredOperation);
2940         DE_UNREF(pInfo);
2941         return VK_SUCCESS;
2942 }
2943
2944 VKAPI_ATTR VkResult VKAPI_CALL copyAccelerationStructureToMemoryKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
2945 {
2946         DE_UNREF(device);
2947         DE_UNREF(deferredOperation);
2948         DE_UNREF(pInfo);
2949         return VK_SUCCESS;
2950 }
2951
2952 VKAPI_ATTR VkResult VKAPI_CALL copyMemoryToAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
2953 {
2954         DE_UNREF(device);
2955         DE_UNREF(deferredOperation);
2956         DE_UNREF(pInfo);
2957         return VK_SUCCESS;
2958 }
2959
2960 VKAPI_ATTR VkResult VKAPI_CALL writeAccelerationStructuresPropertiesKHR (VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride)
2961 {
2962         DE_UNREF(device);
2963         DE_UNREF(accelerationStructureCount);
2964         DE_UNREF(pAccelerationStructures);
2965         DE_UNREF(queryType);
2966         DE_UNREF(dataSize);
2967         DE_UNREF(pData);
2968         DE_UNREF(stride);
2969         return VK_SUCCESS;
2970 }
2971
2972 VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo)
2973 {
2974         DE_UNREF(commandBuffer);
2975         DE_UNREF(pInfo);
2976 }
2977
2978 VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureToMemoryKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
2979 {
2980         DE_UNREF(commandBuffer);
2981         DE_UNREF(pInfo);
2982 }
2983
2984 VKAPI_ATTR void VKAPI_CALL cmdCopyMemoryToAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
2985 {
2986         DE_UNREF(commandBuffer);
2987         DE_UNREF(pInfo);
2988 }
2989
2990 VKAPI_ATTR VkDeviceAddress VKAPI_CALL getAccelerationStructureDeviceAddressKHR (VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
2991 {
2992         DE_UNREF(device);
2993         DE_UNREF(pInfo);
2994         return VK_SUCCESS;
2995 }
2996
2997 VKAPI_ATTR void VKAPI_CALL cmdWriteAccelerationStructuresPropertiesKHR (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2998 {
2999         DE_UNREF(commandBuffer);
3000         DE_UNREF(accelerationStructureCount);
3001         DE_UNREF(pAccelerationStructures);
3002         DE_UNREF(queryType);
3003         DE_UNREF(queryPool);
3004         DE_UNREF(firstQuery);
3005 }
3006
3007 VKAPI_ATTR void VKAPI_CALL getDeviceAccelerationStructureCompatibilityKHR (VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility)
3008 {
3009         DE_UNREF(device);
3010         DE_UNREF(pVersionInfo);
3011         DE_UNREF(pCompatibility);
3012 }
3013
3014 VKAPI_ATTR void VKAPI_CALL getAccelerationStructureBuildSizesKHR (VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo)
3015 {
3016         DE_UNREF(device);
3017         DE_UNREF(buildType);
3018         DE_UNREF(pBuildInfo);
3019         DE_UNREF(pMaxPrimitiveCounts);
3020         DE_UNREF(pSizeInfo);
3021 }
3022
3023 VKAPI_ATTR void VKAPI_CALL cmdTraceRaysKHR (VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
3024 {
3025         DE_UNREF(commandBuffer);
3026         DE_UNREF(pRaygenShaderBindingTable);
3027         DE_UNREF(pMissShaderBindingTable);
3028         DE_UNREF(pHitShaderBindingTable);
3029         DE_UNREF(pCallableShaderBindingTable);
3030         DE_UNREF(width);
3031         DE_UNREF(height);
3032         DE_UNREF(depth);
3033 }
3034
3035 VKAPI_ATTR VkResult VKAPI_CALL getRayTracingCaptureReplayShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
3036 {
3037         DE_UNREF(device);
3038         DE_UNREF(pipeline);
3039         DE_UNREF(firstGroup);
3040         DE_UNREF(groupCount);
3041         DE_UNREF(dataSize);
3042         DE_UNREF(pData);
3043         return VK_SUCCESS;
3044 }
3045
3046 VKAPI_ATTR void VKAPI_CALL cmdTraceRaysIndirectKHR (VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
3047 {
3048         DE_UNREF(commandBuffer);
3049         DE_UNREF(pRaygenShaderBindingTable);
3050         DE_UNREF(pMissShaderBindingTable);
3051         DE_UNREF(pHitShaderBindingTable);
3052         DE_UNREF(pCallableShaderBindingTable);
3053         DE_UNREF(indirectDeviceAddress);
3054 }
3055
3056 VKAPI_ATTR VkDeviceSize VKAPI_CALL getRayTracingShaderGroupStackSizeKHR (VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
3057 {
3058         DE_UNREF(device);
3059         DE_UNREF(pipeline);
3060         DE_UNREF(group);
3061         DE_UNREF(groupShader);
3062         return VK_SUCCESS;
3063 }
3064
3065 VKAPI_ATTR void VKAPI_CALL cmdSetRayTracingPipelineStackSizeKHR (VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
3066 {
3067         DE_UNREF(commandBuffer);
3068         DE_UNREF(pipelineStackSize);
3069 }
3070
3071 VKAPI_ATTR VkResult VKAPI_CALL getAndroidHardwareBufferPropertiesANDROID (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties)
3072 {
3073         DE_UNREF(device);
3074         DE_UNREF(buffer);
3075         DE_UNREF(pProperties);
3076         return VK_SUCCESS;
3077 }
3078
3079 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoCapabilitiesKHR (VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities)
3080 {
3081         DE_UNREF(physicalDevice);
3082         DE_UNREF(pVideoProfile);
3083         DE_UNREF(pCapabilities);
3084         return VK_SUCCESS;
3085 }
3086
3087 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoFormatPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties)
3088 {
3089         DE_UNREF(physicalDevice);
3090         DE_UNREF(pVideoFormatInfo);
3091         DE_UNREF(pVideoFormatPropertyCount);
3092         DE_UNREF(pVideoFormatProperties);
3093         return VK_SUCCESS;
3094 }
3095
3096 VKAPI_ATTR VkResult VKAPI_CALL getVideoSessionMemoryRequirementsKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements)
3097 {
3098         DE_UNREF(device);
3099         DE_UNREF(videoSession);
3100         DE_UNREF(pVideoSessionMemoryRequirementsCount);
3101         DE_UNREF(pVideoSessionMemoryRequirements);
3102         return VK_SUCCESS;
3103 }
3104
3105 VKAPI_ATTR VkResult VKAPI_CALL bindVideoSessionMemoryKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories)
3106 {
3107         DE_UNREF(device);
3108         DE_UNREF(videoSession);
3109         DE_UNREF(videoSessionBindMemoryCount);
3110         DE_UNREF(pVideoSessionBindMemories);
3111         return VK_SUCCESS;
3112 }
3113
3114 VKAPI_ATTR VkResult VKAPI_CALL updateVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo)
3115 {
3116         DE_UNREF(device);
3117         DE_UNREF(videoSessionParameters);
3118         DE_UNREF(pUpdateInfo);
3119         return VK_SUCCESS;
3120 }
3121
3122 VKAPI_ATTR void VKAPI_CALL cmdBeginVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo)
3123 {
3124         DE_UNREF(commandBuffer);
3125         DE_UNREF(pBeginInfo);
3126 }
3127
3128 VKAPI_ATTR void VKAPI_CALL cmdEndVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo)
3129 {
3130         DE_UNREF(commandBuffer);
3131         DE_UNREF(pEndCodingInfo);
3132 }
3133
3134 VKAPI_ATTR void VKAPI_CALL cmdControlVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo)
3135 {
3136         DE_UNREF(commandBuffer);
3137         DE_UNREF(pCodingControlInfo);
3138 }
3139
3140 VKAPI_ATTR void VKAPI_CALL cmdDecodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo)
3141 {
3142         DE_UNREF(commandBuffer);
3143         DE_UNREF(pFrameInfo);
3144 }
3145
3146 VKAPI_ATTR void VKAPI_CALL cmdEncodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo)
3147 {
3148         DE_UNREF(commandBuffer);
3149         DE_UNREF(pEncodeInfo);
3150 }
3151
3152 VKAPI_ATTR VkResult VKAPI_CALL getMemoryZirconHandleFUCHSIA (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle)
3153 {
3154         DE_UNREF(device);
3155         DE_UNREF(pGetZirconHandleInfo);
3156         DE_UNREF(pZirconHandle);
3157         return VK_SUCCESS;
3158 }
3159
3160 VKAPI_ATTR VkResult VKAPI_CALL getMemoryZirconHandlePropertiesFUCHSIA (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties)
3161 {
3162         DE_UNREF(device);
3163         DE_UNREF(handleType);
3164         DE_UNREF(zirconHandle);
3165         DE_UNREF(pMemoryZirconHandleProperties);
3166         return VK_SUCCESS;
3167 }
3168
3169 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
3170 {
3171         DE_UNREF(device);
3172         DE_UNREF(pImportSemaphoreZirconHandleInfo);
3173         return VK_SUCCESS;
3174 }
3175
3176 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle)
3177 {
3178         DE_UNREF(device);
3179         DE_UNREF(pGetZirconHandleInfo);
3180         DE_UNREF(pZirconHandle);
3181         return VK_SUCCESS;
3182 }
3183
3184 VKAPI_ATTR VkResult VKAPI_CALL setBufferCollectionImageConstraintsFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo)
3185 {
3186         DE_UNREF(device);
3187         DE_UNREF(collection);
3188         DE_UNREF(pImageConstraintsInfo);
3189         return VK_SUCCESS;
3190 }
3191
3192 VKAPI_ATTR VkResult VKAPI_CALL setBufferCollectionBufferConstraintsFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo)
3193 {
3194         DE_UNREF(device);
3195         DE_UNREF(collection);
3196         DE_UNREF(pBufferConstraintsInfo);
3197         return VK_SUCCESS;
3198 }
3199
3200 VKAPI_ATTR VkResult VKAPI_CALL getBufferCollectionPropertiesFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties)
3201 {
3202         DE_UNREF(device);
3203         DE_UNREF(collection);
3204         DE_UNREF(pProperties);
3205         return VK_SUCCESS;
3206 }
3207
3208 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWaylandPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::WaylandDisplayPtr display)
3209 {
3210         DE_UNREF(physicalDevice);
3211         DE_UNREF(queueFamilyIndex);
3212         DE_UNREF(display);
3213         return VK_SUCCESS;
3214 }
3215
3216 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
3217 {
3218         DE_UNREF(physicalDevice);
3219         DE_UNREF(queueFamilyIndex);
3220         return VK_SUCCESS;
3221 }
3222
3223 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
3224 {
3225         DE_UNREF(device);
3226         DE_UNREF(pGetWin32HandleInfo);
3227         DE_UNREF(pHandle);
3228         return VK_SUCCESS;
3229 }
3230
3231 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
3232 {
3233         DE_UNREF(device);
3234         DE_UNREF(handleType);
3235         DE_UNREF(handle);
3236         DE_UNREF(pMemoryWin32HandleProperties);
3237         return VK_SUCCESS;
3238 }
3239
3240 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreWin32HandleKHR (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
3241 {
3242         DE_UNREF(device);
3243         DE_UNREF(pImportSemaphoreWin32HandleInfo);
3244         return VK_SUCCESS;
3245 }
3246
3247 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreWin32HandleKHR (VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
3248 {
3249         DE_UNREF(device);
3250         DE_UNREF(pGetWin32HandleInfo);
3251         DE_UNREF(pHandle);
3252         return VK_SUCCESS;
3253 }
3254
3255 VKAPI_ATTR VkResult VKAPI_CALL importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
3256 {
3257         DE_UNREF(device);
3258         DE_UNREF(pImportFenceWin32HandleInfo);
3259         return VK_SUCCESS;
3260 }
3261
3262 VKAPI_ATTR VkResult VKAPI_CALL getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
3263 {
3264         DE_UNREF(device);
3265         DE_UNREF(pGetWin32HandleInfo);
3266         DE_UNREF(pHandle);
3267         return VK_SUCCESS;
3268 }
3269
3270 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle)
3271 {
3272         DE_UNREF(device);
3273         DE_UNREF(memory);
3274         DE_UNREF(handleType);
3275         DE_UNREF(pHandle);
3276         return VK_SUCCESS;
3277 }
3278
3279 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModes2EXT (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
3280 {
3281         DE_UNREF(physicalDevice);
3282         DE_UNREF(pSurfaceInfo);
3283         DE_UNREF(pPresentModeCount);
3284         DE_UNREF(pPresentModes);
3285         return VK_SUCCESS;
3286 }
3287
3288 VKAPI_ATTR VkResult VKAPI_CALL acquireFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain)
3289 {
3290         DE_UNREF(device);
3291         DE_UNREF(swapchain);
3292         return VK_SUCCESS;
3293 }
3294
3295 VKAPI_ATTR VkResult VKAPI_CALL releaseFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain)
3296 {
3297         DE_UNREF(device);
3298         DE_UNREF(swapchain);
3299         return VK_SUCCESS;
3300 }
3301
3302 VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupSurfacePresentModes2EXT (VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes)
3303 {
3304         DE_UNREF(device);
3305         DE_UNREF(pSurfaceInfo);
3306         DE_UNREF(pModes);
3307         return VK_SUCCESS;
3308 }
3309
3310 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXcbPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XcbConnectionPtr connection, pt::XcbVisualid visual_id)
3311 {
3312         DE_UNREF(physicalDevice);
3313         DE_UNREF(queueFamilyIndex);
3314         DE_UNREF(connection);
3315         DE_UNREF(visual_id);
3316         return VK_SUCCESS;
3317 }
3318
3319 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXlibPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XlibDisplayPtr dpy, pt::XlibVisualID visualID)
3320 {
3321         DE_UNREF(physicalDevice);
3322         DE_UNREF(queueFamilyIndex);
3323         DE_UNREF(dpy);
3324         DE_UNREF(visualID);
3325         return VK_SUCCESS;
3326 }
3327
3328 VKAPI_ATTR VkResult VKAPI_CALL acquireXlibDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, VkDisplayKHR display)
3329 {
3330         DE_UNREF(physicalDevice);
3331         DE_UNREF(dpy);
3332         DE_UNREF(display);
3333         return VK_SUCCESS;
3334 }
3335
3336 VKAPI_ATTR VkResult VKAPI_CALL getRandROutputDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, pt::RROutput rrOutput, VkDisplayKHR* pDisplay)
3337 {
3338         DE_UNREF(physicalDevice);
3339         DE_UNREF(dpy);
3340         DE_UNREF(rrOutput);
3341         DE_UNREF(pDisplay);
3342         return VK_SUCCESS;
3343 }
3344
3345 static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
3346 {
3347         VK_NULL_FUNC_ENTRY(vkCreateInstance,                                            createInstance),
3348         VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr,                                       getInstanceProcAddr),
3349         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceExtensionProperties,      enumerateInstanceExtensionProperties),
3350         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceLayerProperties,          enumerateInstanceLayerProperties),
3351         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceVersion,                          enumerateInstanceVersion),
3352 };
3353
3354 static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
3355 {
3356         VK_NULL_FUNC_ENTRY(vkDestroyInstance,                                                                                                   destroyInstance),
3357         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDevices,                                                                                  enumeratePhysicalDevices),
3358         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures,                                                                                 getPhysicalDeviceFeatures),
3359         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties,                                                                 getPhysicalDeviceFormatProperties),
3360         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties,                                                    getPhysicalDeviceImageFormatProperties),
3361         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties,                                                                               getPhysicalDeviceProperties),
3362         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties,                                                    getPhysicalDeviceQueueFamilyProperties),
3363         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties,                                                                 getPhysicalDeviceMemoryProperties),
3364         VK_NULL_FUNC_ENTRY(vkCreateDevice,                                                                                                              createDevice),
3365         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceExtensionProperties,                                                                enumerateDeviceExtensionProperties),
3366         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceLayerProperties,                                                                    enumerateDeviceLayerProperties),
3367         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties,                                              getPhysicalDeviceSparseImageFormatProperties),
3368         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceGroups,                                                                             enumeratePhysicalDeviceGroups),
3369         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures2,                                                                                getPhysicalDeviceFeatures2),
3370         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties2,                                                                              getPhysicalDeviceProperties2),
3371         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties2,                                                                getPhysicalDeviceFormatProperties2),
3372         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties2,                                                   getPhysicalDeviceImageFormatProperties2),
3373         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2,                                                   getPhysicalDeviceQueueFamilyProperties2),
3374         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2,                                                                getPhysicalDeviceMemoryProperties2),
3375         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2,                                             getPhysicalDeviceSparseImageFormatProperties2),
3376         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferProperties,                                                 getPhysicalDeviceExternalBufferProperties),
3377         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFenceProperties,                                                  getPhysicalDeviceExternalFenceProperties),
3378         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphoreProperties,                                              getPhysicalDeviceExternalSemaphoreProperties),
3379         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceToolProperties,                                                                   getPhysicalDeviceToolProperties),
3380         VK_NULL_FUNC_ENTRY(vkDestroySurfaceKHR,                                                                                                 destroySurfaceKHR),
3381         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceSupportKHR,                                                                getPhysicalDeviceSurfaceSupportKHR),
3382         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilitiesKHR,                                                   getPhysicalDeviceSurfaceCapabilitiesKHR),
3383         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormatsKHR,                                                                getPhysicalDeviceSurfaceFormatsKHR),
3384         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModesKHR,                                                   getPhysicalDeviceSurfacePresentModesKHR),
3385         VK_NULL_FUNC_ENTRY(vkGetPhysicalDevicePresentRectanglesKHR,                                                             getPhysicalDevicePresentRectanglesKHR),
3386         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPropertiesKHR,                                                             getPhysicalDeviceDisplayPropertiesKHR),
3387         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlanePropertiesKHR,                                                getPhysicalDeviceDisplayPlanePropertiesKHR),
3388         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneSupportedDisplaysKHR,                                                               getDisplayPlaneSupportedDisplaysKHR),
3389         VK_NULL_FUNC_ENTRY(vkGetDisplayModePropertiesKHR,                                                                               getDisplayModePropertiesKHR),
3390         VK_NULL_FUNC_ENTRY(vkCreateDisplayModeKHR,                                                                                              createDisplayModeKHR),
3391         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilitiesKHR,                                                                    getDisplayPlaneCapabilitiesKHR),
3392         VK_NULL_FUNC_ENTRY(vkCreateDisplayPlaneSurfaceKHR,                                                                              createDisplayPlaneSurfaceKHR),
3393         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures2KHR,                                                                             getPhysicalDeviceFeatures2),
3394         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties2KHR,                                                                   getPhysicalDeviceProperties2),
3395         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties2KHR,                                                             getPhysicalDeviceFormatProperties2),
3396         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties2KHR,                                                getPhysicalDeviceImageFormatProperties2),
3397         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2KHR,                                                getPhysicalDeviceQueueFamilyProperties2),
3398         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2KHR,                                                             getPhysicalDeviceMemoryProperties2),
3399         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2KHR,                                  getPhysicalDeviceSparseImageFormatProperties2),
3400         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceGroupsKHR,                                                                  enumeratePhysicalDeviceGroups),
3401         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferPropertiesKHR,                                              getPhysicalDeviceExternalBufferProperties),
3402         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,                                   getPhysicalDeviceExternalSemaphoreProperties),
3403         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFencePropertiesKHR,                                               getPhysicalDeviceExternalFenceProperties),
3404         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,             enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR),
3405         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,                             getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR),
3406         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2KHR,                                                  getPhysicalDeviceSurfaceCapabilities2KHR),
3407         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormats2KHR,                                                               getPhysicalDeviceSurfaceFormats2KHR),
3408         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayProperties2KHR,                                                    getPhysicalDeviceDisplayProperties2KHR),
3409         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlaneProperties2KHR,                                               getPhysicalDeviceDisplayPlaneProperties2KHR),
3410         VK_NULL_FUNC_ENTRY(vkGetDisplayModeProperties2KHR,                                                                              getDisplayModeProperties2KHR),
3411         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilities2KHR,                                                                   getDisplayPlaneCapabilities2KHR),
3412         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFragmentShadingRatesKHR,                                                  getPhysicalDeviceFragmentShadingRatesKHR),
3413         VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT,                                                                              createDebugReportCallbackEXT),
3414         VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT,                                                                             destroyDebugReportCallbackEXT),
3415         VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT,                                                                                             debugReportMessageEXT),
3416         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalImageFormatPropertiesNV,                                  getPhysicalDeviceExternalImageFormatPropertiesNV),
3417         VK_NULL_FUNC_ENTRY(vkReleaseDisplayEXT,                                                                                                 releaseDisplayEXT),
3418         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2EXT,                                                  getPhysicalDeviceSurfaceCapabilities2EXT),
3419         VK_NULL_FUNC_ENTRY(vkCreateDebugUtilsMessengerEXT,                                                                              createDebugUtilsMessengerEXT),
3420         VK_NULL_FUNC_ENTRY(vkDestroyDebugUtilsMessengerEXT,                                                                             destroyDebugUtilsMessengerEXT),
3421         VK_NULL_FUNC_ENTRY(vkSubmitDebugUtilsMessageEXT,                                                                                submitDebugUtilsMessageEXT),
3422         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMultisamplePropertiesEXT,                                                 getPhysicalDeviceMultisamplePropertiesEXT),
3423         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,                                              getPhysicalDeviceCalibrateableTimeDomainsEXT),
3424         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceToolPropertiesEXT,                                                                getPhysicalDeviceToolProperties),
3425         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,                                    getPhysicalDeviceCooperativeMatrixPropertiesNV),
3426         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,   getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV),
3427         VK_NULL_FUNC_ENTRY(vkCreateHeadlessSurfaceEXT,                                                                                  createHeadlessSurfaceEXT),
3428         VK_NULL_FUNC_ENTRY(vkAcquireDrmDisplayEXT,                                                                                              acquireDrmDisplayEXT),
3429         VK_NULL_FUNC_ENTRY(vkGetDrmDisplayEXT,                                                                                                  getDrmDisplayEXT),
3430         VK_NULL_FUNC_ENTRY(vkAcquireWinrtDisplayNV,                                                                                             acquireWinrtDisplayNV),
3431         VK_NULL_FUNC_ENTRY(vkGetWinrtDisplayNV,                                                                                                 getWinrtDisplayNV),
3432         VK_NULL_FUNC_ENTRY(vkCreateAndroidSurfaceKHR,                                                                                   createAndroidSurfaceKHR),
3433         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoCapabilitiesKHR,                                                             getPhysicalDeviceVideoCapabilitiesKHR),
3434         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoFormatPropertiesKHR,                                                 getPhysicalDeviceVideoFormatPropertiesKHR),
3435         VK_NULL_FUNC_ENTRY(vkCreateImagePipeSurfaceFUCHSIA,                                                                             createImagePipeSurfaceFUCHSIA),
3436         VK_NULL_FUNC_ENTRY(vkCreateStreamDescriptorSurfaceGGP,                                                                  createStreamDescriptorSurfaceGGP),
3437         VK_NULL_FUNC_ENTRY(vkCreateIOSSurfaceMVK,                                                                                               createIOSSurfaceMVK),
3438         VK_NULL_FUNC_ENTRY(vkCreateMacOSSurfaceMVK,                                                                                             createMacOSSurfaceMVK),
3439         VK_NULL_FUNC_ENTRY(vkCreateMetalSurfaceEXT,                                                                                             createMetalSurfaceEXT),
3440         VK_NULL_FUNC_ENTRY(vkCreateViSurfaceNN,                                                                                                 createViSurfaceNN),
3441         VK_NULL_FUNC_ENTRY(vkCreateWaylandSurfaceKHR,                                                                                   createWaylandSurfaceKHR),
3442         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWaylandPresentationSupportKHR,                                    getPhysicalDeviceWaylandPresentationSupportKHR),
3443         VK_NULL_FUNC_ENTRY(vkCreateWin32SurfaceKHR,                                                                                             createWin32SurfaceKHR),
3444         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWin32PresentationSupportKHR,                                              getPhysicalDeviceWin32PresentationSupportKHR),
3445         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModes2EXT,                                                  getPhysicalDeviceSurfacePresentModes2EXT),
3446         VK_NULL_FUNC_ENTRY(vkCreateXcbSurfaceKHR,                                                                                               createXcbSurfaceKHR),
3447         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXcbPresentationSupportKHR,                                                getPhysicalDeviceXcbPresentationSupportKHR),
3448         VK_NULL_FUNC_ENTRY(vkCreateXlibSurfaceKHR,                                                                                              createXlibSurfaceKHR),
3449         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXlibPresentationSupportKHR,                                               getPhysicalDeviceXlibPresentationSupportKHR),
3450         VK_NULL_FUNC_ENTRY(vkAcquireXlibDisplayEXT,                                                                                             acquireXlibDisplayEXT),
3451         VK_NULL_FUNC_ENTRY(vkGetRandROutputDisplayEXT,                                                                                  getRandROutputDisplayEXT),
3452 };
3453
3454 static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
3455 {
3456         VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr,                                                                 getDeviceProcAddr),
3457         VK_NULL_FUNC_ENTRY(vkDestroyDevice,                                                                             destroyDevice),
3458         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue,                                                                    getDeviceQueue),
3459         VK_NULL_FUNC_ENTRY(vkQueueSubmit,                                                                               queueSubmit),
3460         VK_NULL_FUNC_ENTRY(vkQueueWaitIdle,                                                                             queueWaitIdle),
3461         VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle,                                                                    deviceWaitIdle),
3462         VK_NULL_FUNC_ENTRY(vkAllocateMemory,                                                                    allocateMemory),
3463         VK_NULL_FUNC_ENTRY(vkFreeMemory,                                                                                freeMemory),
3464         VK_NULL_FUNC_ENTRY(vkMapMemory,                                                                                 mapMemory),
3465         VK_NULL_FUNC_ENTRY(vkUnmapMemory,                                                                               unmapMemory),
3466         VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges,                                                   flushMappedMemoryRanges),
3467         VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges,                                              invalidateMappedMemoryRanges),
3468         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment,                                                 getDeviceMemoryCommitment),
3469         VK_NULL_FUNC_ENTRY(vkBindBufferMemory,                                                                  bindBufferMemory),
3470         VK_NULL_FUNC_ENTRY(vkBindImageMemory,                                                                   bindImageMemory),
3471         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements,                                               getBufferMemoryRequirements),
3472         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements,                                                getImageMemoryRequirements),
3473         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements,                                  getImageSparseMemoryRequirements),
3474         VK_NULL_FUNC_ENTRY(vkQueueBindSparse,                                                                   queueBindSparse),
3475         VK_NULL_FUNC_ENTRY(vkCreateFence,                                                                               createFence),
3476         VK_NULL_FUNC_ENTRY(vkDestroyFence,                                                                              destroyFence),
3477         VK_NULL_FUNC_ENTRY(vkResetFences,                                                                               resetFences),
3478         VK_NULL_FUNC_ENTRY(vkGetFenceStatus,                                                                    getFenceStatus),
3479         VK_NULL_FUNC_ENTRY(vkWaitForFences,                                                                             waitForFences),
3480         VK_NULL_FUNC_ENTRY(vkCreateSemaphore,                                                                   createSemaphore),
3481         VK_NULL_FUNC_ENTRY(vkDestroySemaphore,                                                                  destroySemaphore),
3482         VK_NULL_FUNC_ENTRY(vkCreateEvent,                                                                               createEvent),
3483         VK_NULL_FUNC_ENTRY(vkDestroyEvent,                                                                              destroyEvent),
3484         VK_NULL_FUNC_ENTRY(vkGetEventStatus,                                                                    getEventStatus),
3485         VK_NULL_FUNC_ENTRY(vkSetEvent,                                                                                  setEvent),
3486         VK_NULL_FUNC_ENTRY(vkResetEvent,                                                                                resetEvent),
3487         VK_NULL_FUNC_ENTRY(vkCreateQueryPool,                                                                   createQueryPool),
3488         VK_NULL_FUNC_ENTRY(vkDestroyQueryPool,                                                                  destroyQueryPool),
3489         VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults,                                                               getQueryPoolResults),
3490         VK_NULL_FUNC_ENTRY(vkCreateBuffer,                                                                              createBuffer),
3491         VK_NULL_FUNC_ENTRY(vkDestroyBuffer,                                                                             destroyBuffer),
3492         VK_NULL_FUNC_ENTRY(vkCreateBufferView,                                                                  createBufferView),
3493         VK_NULL_FUNC_ENTRY(vkDestroyBufferView,                                                                 destroyBufferView),
3494         VK_NULL_FUNC_ENTRY(vkCreateImage,                                                                               createImage),
3495         VK_NULL_FUNC_ENTRY(vkDestroyImage,                                                                              destroyImage),
3496         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout,                                                 getImageSubresourceLayout),
3497         VK_NULL_FUNC_ENTRY(vkCreateImageView,                                                                   createImageView),
3498         VK_NULL_FUNC_ENTRY(vkDestroyImageView,                                                                  destroyImageView),
3499         VK_NULL_FUNC_ENTRY(vkCreateShaderModule,                                                                createShaderModule),
3500         VK_NULL_FUNC_ENTRY(vkDestroyShaderModule,                                                               destroyShaderModule),
3501         VK_NULL_FUNC_ENTRY(vkCreatePipelineCache,                                                               createPipelineCache),
3502         VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache,                                                              destroyPipelineCache),
3503         VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData,                                                              getPipelineCacheData),
3504         VK_NULL_FUNC_ENTRY(vkMergePipelineCaches,                                                               mergePipelineCaches),
3505         VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines,                                                   createGraphicsPipelines),
3506         VK_NULL_FUNC_ENTRY(vkCreateComputePipelines,                                                    createComputePipelines),
3507         VK_NULL_FUNC_ENTRY(vkDestroyPipeline,                                                                   destroyPipeline),
3508         VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout,                                                              createPipelineLayout),
3509         VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout,                                                             destroyPipelineLayout),
3510         VK_NULL_FUNC_ENTRY(vkCreateSampler,                                                                             createSampler),
3511         VK_NULL_FUNC_ENTRY(vkDestroySampler,                                                                    destroySampler),
3512         VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout,                                                 createDescriptorSetLayout),
3513         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout,                                                destroyDescriptorSetLayout),
3514         VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool,                                                              createDescriptorPool),
3515         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool,                                                             destroyDescriptorPool),
3516         VK_NULL_FUNC_ENTRY(vkResetDescriptorPool,                                                               resetDescriptorPool),
3517         VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets,                                                    allocateDescriptorSets),
3518         VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets,                                                                freeDescriptorSets),
3519         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets,                                                              updateDescriptorSets),
3520         VK_NULL_FUNC_ENTRY(vkCreateFramebuffer,                                                                 createFramebuffer),
3521         VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer,                                                                destroyFramebuffer),
3522         VK_NULL_FUNC_ENTRY(vkCreateRenderPass,                                                                  createRenderPass),
3523         VK_NULL_FUNC_ENTRY(vkDestroyRenderPass,                                                                 destroyRenderPass),
3524         VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity,                                                  getRenderAreaGranularity),
3525         VK_NULL_FUNC_ENTRY(vkCreateCommandPool,                                                                 createCommandPool),
3526         VK_NULL_FUNC_ENTRY(vkDestroyCommandPool,                                                                destroyCommandPool),
3527         VK_NULL_FUNC_ENTRY(vkResetCommandPool,                                                                  resetCommandPool),
3528         VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers,                                                    allocateCommandBuffers),
3529         VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers,                                                                freeCommandBuffers),
3530         VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer,                                                                beginCommandBuffer),
3531         VK_NULL_FUNC_ENTRY(vkEndCommandBuffer,                                                                  endCommandBuffer),
3532         VK_NULL_FUNC_ENTRY(vkResetCommandBuffer,                                                                resetCommandBuffer),
3533         VK_NULL_FUNC_ENTRY(vkCmdBindPipeline,                                                                   cmdBindPipeline),
3534         VK_NULL_FUNC_ENTRY(vkCmdSetViewport,                                                                    cmdSetViewport),
3535         VK_NULL_FUNC_ENTRY(vkCmdSetScissor,                                                                             cmdSetScissor),
3536         VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth,                                                                   cmdSetLineWidth),
3537         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias,                                                                   cmdSetDepthBias),
3538         VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants,                                                              cmdSetBlendConstants),
3539         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds,                                                                 cmdSetDepthBounds),
3540         VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask,                                                  cmdSetStencilCompareMask),
3541         VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask,                                                    cmdSetStencilWriteMask),
3542         VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference,                                                    cmdSetStencilReference),
3543         VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets,                                                             cmdBindDescriptorSets),
3544         VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer,                                                                cmdBindIndexBuffer),
3545         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers,                                                              cmdBindVertexBuffers),
3546         VK_NULL_FUNC_ENTRY(vkCmdDraw,                                                                                   cmdDraw),
3547         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed,                                                                    cmdDrawIndexed),
3548         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect,                                                                   cmdDrawIndirect),
3549         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect,                                                    cmdDrawIndexedIndirect),
3550         VK_NULL_FUNC_ENTRY(vkCmdDispatch,                                                                               cmdDispatch),
3551         VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect,                                                               cmdDispatchIndirect),
3552         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer,                                                                             cmdCopyBuffer),
3553         VK_NULL_FUNC_ENTRY(vkCmdCopyImage,                                                                              cmdCopyImage),
3554         VK_NULL_FUNC_ENTRY(vkCmdBlitImage,                                                                              cmdBlitImage),
3555         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage,                                                              cmdCopyBufferToImage),
3556         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer,                                                              cmdCopyImageToBuffer),
3557         VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer,                                                                   cmdUpdateBuffer),
3558         VK_NULL_FUNC_ENTRY(vkCmdFillBuffer,                                                                             cmdFillBuffer),
3559         VK_NULL_FUNC_ENTRY(vkCmdClearColorImage,                                                                cmdClearColorImage),
3560         VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage,                                                 cmdClearDepthStencilImage),
3561         VK_NULL_FUNC_ENTRY(vkCmdClearAttachments,                                                               cmdClearAttachments),
3562         VK_NULL_FUNC_ENTRY(vkCmdResolveImage,                                                                   cmdResolveImage),
3563         VK_NULL_FUNC_ENTRY(vkCmdSetEvent,                                                                               cmdSetEvent),
3564         VK_NULL_FUNC_ENTRY(vkCmdResetEvent,                                                                             cmdResetEvent),
3565         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents,                                                                             cmdWaitEvents),
3566         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier,                                                                cmdPipelineBarrier),
3567         VK_NULL_FUNC_ENTRY(vkCmdBeginQuery,                                                                             cmdBeginQuery),
3568         VK_NULL_FUNC_ENTRY(vkCmdEndQuery,                                                                               cmdEndQuery),
3569         VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool,                                                                 cmdResetQueryPool),
3570         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp,                                                                 cmdWriteTimestamp),
3571         VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults,                                                   cmdCopyQueryPoolResults),
3572         VK_NULL_FUNC_ENTRY(vkCmdPushConstants,                                                                  cmdPushConstants),
3573         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass,                                                                cmdBeginRenderPass),
3574         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass,                                                                    cmdNextSubpass),
3575         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass,                                                                  cmdEndRenderPass),
3576         VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands,                                                                cmdExecuteCommands),
3577         VK_NULL_FUNC_ENTRY(vkBindBufferMemory2,                                                                 bindBufferMemory2),
3578         VK_NULL_FUNC_ENTRY(vkBindImageMemory2,                                                                  bindImageMemory2),
3579         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeatures,                                  getDeviceGroupPeerMemoryFeatures),
3580         VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMask,                                                                  cmdSetDeviceMask),
3581         VK_NULL_FUNC_ENTRY(vkCmdDispatchBase,                                                                   cmdDispatchBase),
3582         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2,                                               getImageMemoryRequirements2),
3583         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2,                                              getBufferMemoryRequirements2),
3584         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2,                                 getImageSparseMemoryRequirements2),
3585         VK_NULL_FUNC_ENTRY(vkTrimCommandPool,                                                                   trimCommandPool),
3586         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue2,                                                                   getDeviceQueue2),
3587         VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversion,                                              createSamplerYcbcrConversion),
3588         VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversion,                                             destroySamplerYcbcrConversion),
3589         VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplate,                                    createDescriptorUpdateTemplate),
3590         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplate,                                   destroyDescriptorUpdateTemplate),
3591         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplate,                                   updateDescriptorSetWithTemplate),
3592         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupport,                                             getDescriptorSetLayoutSupport),
3593         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCount,                                                              cmdDrawIndirectCount),
3594         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCount,                                               cmdDrawIndexedIndirectCount),
3595         VK_NULL_FUNC_ENTRY(vkCreateRenderPass2,                                                                 createRenderPass2),
3596         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass2,                                                               cmdBeginRenderPass2),
3597         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass2,                                                                   cmdNextSubpass2),
3598         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass2,                                                                 cmdEndRenderPass2),
3599         VK_NULL_FUNC_ENTRY(vkResetQueryPool,                                                                    resetQueryPool),
3600         VK_NULL_FUNC_ENTRY(vkGetSemaphoreCounterValue,                                                  getSemaphoreCounterValue),
3601         VK_NULL_FUNC_ENTRY(vkWaitSemaphores,                                                                    waitSemaphores),
3602         VK_NULL_FUNC_ENTRY(vkSignalSemaphore,                                                                   signalSemaphore),
3603         VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddress,                                                    getBufferDeviceAddress),
3604         VK_NULL_FUNC_ENTRY(vkGetBufferOpaqueCaptureAddress,                                             getBufferOpaqueCaptureAddress),
3605         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryOpaqueCaptureAddress,                               getDeviceMemoryOpaqueCaptureAddress),
3606         VK_NULL_FUNC_ENTRY(vkCreatePrivateDataSlot,                                                             createPrivateDataSlot),
3607         VK_NULL_FUNC_ENTRY(vkDestroyPrivateDataSlot,                                                    destroyPrivateDataSlot),
3608         VK_NULL_FUNC_ENTRY(vkSetPrivateData,                                                                    setPrivateData),
3609         VK_NULL_FUNC_ENTRY(vkGetPrivateData,                                                                    getPrivateData),
3610         VK_NULL_FUNC_ENTRY(vkCmdSetEvent2,                                                                              cmdSetEvent2),
3611         VK_NULL_FUNC_ENTRY(vkCmdResetEvent2,                                                                    cmdResetEvent2),
3612         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents2,                                                                    cmdWaitEvents2),
3613         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier2,                                                               cmdPipelineBarrier2),
3614         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp2,                                                                cmdWriteTimestamp2),
3615         VK_NULL_FUNC_ENTRY(vkQueueSubmit2,                                                                              queueSubmit2),
3616         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer2,                                                                    cmdCopyBuffer2),
3617         VK_NULL_FUNC_ENTRY(vkCmdCopyImage2,                                                                             cmdCopyImage2),
3618         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage2,                                                             cmdCopyBufferToImage2),
3619         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer2,                                                             cmdCopyImageToBuffer2),
3620         VK_NULL_FUNC_ENTRY(vkCmdBlitImage2,                                                                             cmdBlitImage2),
3621         VK_NULL_FUNC_ENTRY(vkCmdResolveImage2,                                                                  cmdResolveImage2),
3622         VK_NULL_FUNC_ENTRY(vkCmdBeginRendering,                                                                 cmdBeginRendering),
3623         VK_NULL_FUNC_ENTRY(vkCmdEndRendering,                                                                   cmdEndRendering),
3624         VK_NULL_FUNC_ENTRY(vkCmdSetCullMode,                                                                    cmdSetCullMode),
3625         VK_NULL_FUNC_ENTRY(vkCmdSetFrontFace,                                                                   cmdSetFrontFace),
3626         VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveTopology,                                                   cmdSetPrimitiveTopology),
3627         VK_NULL_FUNC_ENTRY(vkCmdSetViewportWithCount,                                                   cmdSetViewportWithCount),
3628         VK_NULL_FUNC_ENTRY(vkCmdSetScissorWithCount,                                                    cmdSetScissorWithCount),
3629         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers2,                                                             cmdBindVertexBuffers2),
3630         VK_NULL_FUNC_ENTRY(vkCmdSetDepthTestEnable,                                                             cmdSetDepthTestEnable),
3631         VK_NULL_FUNC_ENTRY(vkCmdSetDepthWriteEnable,                                                    cmdSetDepthWriteEnable),
3632         VK_NULL_FUNC_ENTRY(vkCmdSetDepthCompareOp,                                                              cmdSetDepthCompareOp),
3633         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBoundsTestEnable,                                               cmdSetDepthBoundsTestEnable),
3634         VK_NULL_FUNC_ENTRY(vkCmdSetStencilTestEnable,                                                   cmdSetStencilTestEnable),
3635         VK_NULL_FUNC_ENTRY(vkCmdSetStencilOp,                                                                   cmdSetStencilOp),
3636         VK_NULL_FUNC_ENTRY(vkCmdSetRasterizerDiscardEnable,                                             cmdSetRasterizerDiscardEnable),
3637         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBiasEnable,                                                             cmdSetDepthBiasEnable),
3638         VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveRestartEnable,                                              cmdSetPrimitiveRestartEnable),
3639         VK_NULL_FUNC_ENTRY(vkGetDeviceBufferMemoryRequirements,                                 getDeviceBufferMemoryRequirements),
3640         VK_NULL_FUNC_ENTRY(vkGetDeviceImageMemoryRequirements,                                  getDeviceImageMemoryRequirements),
3641         VK_NULL_FUNC_ENTRY(vkGetDeviceImageSparseMemoryRequirements,                    getDeviceImageSparseMemoryRequirements),
3642         VK_NULL_FUNC_ENTRY(vkCreateSwapchainKHR,                                                                createSwapchainKHR),
3643         VK_NULL_FUNC_ENTRY(vkDestroySwapchainKHR,                                                               destroySwapchainKHR),
3644         VK_NULL_FUNC_ENTRY(vkGetSwapchainImagesKHR,                                                             getSwapchainImagesKHR),
3645         VK_NULL_FUNC_ENTRY(vkAcquireNextImageKHR,                                                               acquireNextImageKHR),
3646         VK_NULL_FUNC_ENTRY(vkQueuePresentKHR,                                                                   queuePresentKHR),
3647         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPresentCapabilitiesKHR,                              getDeviceGroupPresentCapabilitiesKHR),
3648         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModesKHR,                              getDeviceGroupSurfacePresentModesKHR),
3649         VK_NULL_FUNC_ENTRY(vkAcquireNextImage2KHR,                                                              acquireNextImage2KHR),
3650         VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR,                                                 createSharedSwapchainsKHR),
3651         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderingKHR,                                                              cmdBeginRendering),
3652         VK_NULL_FUNC_ENTRY(vkCmdEndRenderingKHR,                                                                cmdEndRendering),
3653         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeaturesKHR,                               getDeviceGroupPeerMemoryFeatures),
3654         VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMaskKHR,                                                               cmdSetDeviceMask),
3655         VK_NULL_FUNC_ENTRY(vkCmdDispatchBaseKHR,                                                                cmdDispatchBase),
3656         VK_NULL_FUNC_ENTRY(vkTrimCommandPoolKHR,                                                                trimCommandPool),
3657         VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHR,                                                                    getMemoryFdKHR),
3658         VK_NULL_FUNC_ENTRY(vkGetMemoryFdPropertiesKHR,                                                  getMemoryFdPropertiesKHR),
3659         VK_NULL_FUNC_ENTRY(vkImportSemaphoreFdKHR,                                                              importSemaphoreFdKHR),
3660         VK_NULL_FUNC_ENTRY(vkGetSemaphoreFdKHR,                                                                 getSemaphoreFdKHR),
3661         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR,                                                   cmdPushDescriptorSetKHR),
3662         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR,                               cmdPushDescriptorSetWithTemplateKHR),
3663         VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplateKHR,                                 createDescriptorUpdateTemplate),
3664         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplateKHR,                                destroyDescriptorUpdateTemplate),
3665         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplateKHR,                                updateDescriptorSetWithTemplate),
3666         VK_NULL_FUNC_ENTRY(vkCreateRenderPass2KHR,                                                              createRenderPass2),
3667         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass2KHR,                                                    cmdBeginRenderPass2),
3668         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass2KHR,                                                                cmdNextSubpass2),
3669         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass2KHR,                                                              cmdEndRenderPass2),
3670         VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR,                                                             getSwapchainStatusKHR),
3671         VK_NULL_FUNC_ENTRY(vkImportFenceFdKHR,                                                                  importFenceFdKHR),
3672         VK_NULL_FUNC_ENTRY(vkGetFenceFdKHR,                                                                             getFenceFdKHR),
3673         VK_NULL_FUNC_ENTRY(vkAcquireProfilingLockKHR,                                                   acquireProfilingLockKHR),
3674         VK_NULL_FUNC_ENTRY(vkReleaseProfilingLockKHR,                                                   releaseProfilingLockKHR),
3675         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2KHR,                                    getImageMemoryRequirements2),
3676         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2KHR,                                   getBufferMemoryRequirements2),
3677         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2KHR,                              getImageSparseMemoryRequirements2),
3678         VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversionKHR,                                   createSamplerYcbcrConversion),
3679         VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversionKHR,                                  destroySamplerYcbcrConversion),
3680         VK_NULL_FUNC_ENTRY(vkBindBufferMemory2KHR,                                                              bindBufferMemory2),
3681         VK_NULL_FUNC_ENTRY(vkBindImageMemory2KHR,                                                               bindImageMemory2),
3682         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupportKHR,                                  getDescriptorSetLayoutSupport),
3683         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountKHR,                                                   cmdDrawIndirectCount),
3684         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountKHR,                                    cmdDrawIndexedIndirectCount),
3685         VK_NULL_FUNC_ENTRY(vkGetSemaphoreCounterValueKHR,                                               getSemaphoreCounterValue),
3686         VK_NULL_FUNC_ENTRY(vkWaitSemaphoresKHR,                                                                 waitSemaphores),
3687         VK_NULL_FUNC_ENTRY(vkSignalSemaphoreKHR,                                                                signalSemaphore),
3688         VK_NULL_FUNC_ENTRY(vkCmdSetFragmentShadingRateKHR,                                              cmdSetFragmentShadingRateKHR),
3689         VK_NULL_FUNC_ENTRY(vkWaitForPresentKHR,                                                                 waitForPresentKHR),
3690         VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddressKHR,                                                 getBufferDeviceAddress),
3691         VK_NULL_FUNC_ENTRY(vkGetBufferOpaqueCaptureAddressKHR,                                  getBufferOpaqueCaptureAddress),
3692         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryOpaqueCaptureAddressKHR,                    getDeviceMemoryOpaqueCaptureAddress),
3693         VK_NULL_FUNC_ENTRY(vkCreateDeferredOperationKHR,                                                createDeferredOperationKHR),
3694         VK_NULL_FUNC_ENTRY(vkDestroyDeferredOperationKHR,                                               destroyDeferredOperationKHR),
3695         VK_NULL_FUNC_ENTRY(vkGetDeferredOperationMaxConcurrencyKHR,                             getDeferredOperationMaxConcurrencyKHR),
3696         VK_NULL_FUNC_ENTRY(vkGetDeferredOperationResultKHR,                                             getDeferredOperationResultKHR),
3697         VK_NULL_FUNC_ENTRY(vkDeferredOperationJoinKHR,                                                  deferredOperationJoinKHR),
3698         VK_NULL_FUNC_ENTRY(vkGetPipelineExecutablePropertiesKHR,                                getPipelineExecutablePropertiesKHR),
3699         VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableStatisticsKHR,                                getPipelineExecutableStatisticsKHR),
3700         VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableInternalRepresentationsKHR,   getPipelineExecutableInternalRepresentationsKHR),
3701         VK_NULL_FUNC_ENTRY(vkCmdSetEvent2KHR,                                                                   cmdSetEvent2),
3702         VK_NULL_FUNC_ENTRY(vkCmdResetEvent2KHR,                                                                 cmdResetEvent2),
3703         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents2KHR,                                                                 cmdWaitEvents2),
3704         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier2KHR,                                                    cmdPipelineBarrier2),
3705         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp2KHR,                                                             cmdWriteTimestamp2),
3706         VK_NULL_FUNC_ENTRY(vkQueueSubmit2KHR,                                                                   queueSubmit2),
3707         VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarker2AMD,                                                  cmdWriteBufferMarker2AMD),
3708         VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointData2NV,                                                 getQueueCheckpointData2NV),
3709         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer2KHR,                                                                 cmdCopyBuffer2),
3710         VK_NULL_FUNC_ENTRY(vkCmdCopyImage2KHR,                                                                  cmdCopyImage2),
3711         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage2KHR,                                                  cmdCopyBufferToImage2),
3712         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer2KHR,                                                  cmdCopyImageToBuffer2),
3713         VK_NULL_FUNC_ENTRY(vkCmdBlitImage2KHR,                                                                  cmdBlitImage2),
3714         VK_NULL_FUNC_ENTRY(vkCmdResolveImage2KHR,                                                               cmdResolveImage2),
3715         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysIndirect2KHR,                                                  cmdTraceRaysIndirect2KHR),
3716         VK_NULL_FUNC_ENTRY(vkGetDeviceBufferMemoryRequirementsKHR,                              getDeviceBufferMemoryRequirements),
3717         VK_NULL_FUNC_ENTRY(vkGetDeviceImageMemoryRequirementsKHR,                               getDeviceImageMemoryRequirements),
3718         VK_NULL_FUNC_ENTRY(vkGetDeviceImageSparseMemoryRequirementsKHR,                 getDeviceImageSparseMemoryRequirements),
3719         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectTagEXT,                                                debugMarkerSetObjectTagEXT),
3720         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectNameEXT,                                               debugMarkerSetObjectNameEXT),
3721         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerBeginEXT,                                                    cmdDebugMarkerBeginEXT),
3722         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerEndEXT,                                                              cmdDebugMarkerEndEXT),
3723         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerInsertEXT,                                                   cmdDebugMarkerInsertEXT),
3724         VK_NULL_FUNC_ENTRY(vkCmdBindTransformFeedbackBuffersEXT,                                cmdBindTransformFeedbackBuffersEXT),
3725         VK_NULL_FUNC_ENTRY(vkCmdBeginTransformFeedbackEXT,                                              cmdBeginTransformFeedbackEXT),
3726         VK_NULL_FUNC_ENTRY(vkCmdEndTransformFeedbackEXT,                                                cmdEndTransformFeedbackEXT),
3727         VK_NULL_FUNC_ENTRY(vkCmdBeginQueryIndexedEXT,                                                   cmdBeginQueryIndexedEXT),
3728         VK_NULL_FUNC_ENTRY(vkCmdEndQueryIndexedEXT,                                                             cmdEndQueryIndexedEXT),
3729         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectByteCountEXT,                                               cmdDrawIndirectByteCountEXT),
3730         VK_NULL_FUNC_ENTRY(vkCreateCuModuleNVX,                                                                 createCuModuleNVX),
3731         VK_NULL_FUNC_ENTRY(vkCreateCuFunctionNVX,                                                               createCuFunctionNVX),
3732         VK_NULL_FUNC_ENTRY(vkDestroyCuModuleNVX,                                                                destroyCuModuleNVX),
3733         VK_NULL_FUNC_ENTRY(vkDestroyCuFunctionNVX,                                                              destroyCuFunctionNVX),
3734         VK_NULL_FUNC_ENTRY(vkCmdCuLaunchKernelNVX,                                                              cmdCuLaunchKernelNVX),
3735         VK_NULL_FUNC_ENTRY(vkGetImageViewHandleNVX,                                                             getImageViewHandleNVX),
3736         VK_NULL_FUNC_ENTRY(vkGetImageViewAddressNVX,                                                    getImageViewAddressNVX),
3737         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountAMD,                                                   cmdDrawIndirectCountAMD),
3738         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountAMD,                                    cmdDrawIndexedIndirectCountAMD),
3739         VK_NULL_FUNC_ENTRY(vkGetShaderInfoAMD,                                                                  getShaderInfoAMD),
3740         VK_NULL_FUNC_ENTRY(vkCmdBeginConditionalRenderingEXT,                                   cmdBeginConditionalRenderingEXT),
3741         VK_NULL_FUNC_ENTRY(vkCmdEndConditionalRenderingEXT,                                             cmdEndConditionalRenderingEXT),
3742         VK_NULL_FUNC_ENTRY(vkCmdSetViewportWScalingNV,                                                  cmdSetViewportWScalingNV),
3743         VK_NULL_FUNC_ENTRY(vkDisplayPowerControlEXT,                                                    displayPowerControlEXT),
3744         VK_NULL_FUNC_ENTRY(vkRegisterDeviceEventEXT,                                                    registerDeviceEventEXT),
3745         VK_NULL_FUNC_ENTRY(vkRegisterDisplayEventEXT,                                                   registerDisplayEventEXT),
3746         VK_NULL_FUNC_ENTRY(vkGetSwapchainCounterEXT,                                                    getSwapchainCounterEXT),
3747         VK_NULL_FUNC_ENTRY(vkGetRefreshCycleDurationGOOGLE,                                             getRefreshCycleDurationGOOGLE),
3748         VK_NULL_FUNC_ENTRY(vkGetPastPresentationTimingGOOGLE,                                   getPastPresentationTimingGOOGLE),
3749         VK_NULL_FUNC_ENTRY(vkCmdSetDiscardRectangleEXT,                                                 cmdSetDiscardRectangleEXT),
3750         VK_NULL_FUNC_ENTRY(vkSetHdrMetadataEXT,                                                                 setHdrMetadataEXT),
3751         VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectNameEXT,                                                setDebugUtilsObjectNameEXT),
3752         VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectTagEXT,                                                 setDebugUtilsObjectTagEXT),
3753         VK_NULL_FUNC_ENTRY(vkQueueBeginDebugUtilsLabelEXT,                                              queueBeginDebugUtilsLabelEXT),
3754         VK_NULL_FUNC_ENTRY(vkQueueEndDebugUtilsLabelEXT,                                                queueEndDebugUtilsLabelEXT),
3755         VK_NULL_FUNC_ENTRY(vkQueueInsertDebugUtilsLabelEXT,                                             queueInsertDebugUtilsLabelEXT),
3756         VK_NULL_FUNC_ENTRY(vkCmdBeginDebugUtilsLabelEXT,                                                cmdBeginDebugUtilsLabelEXT),
3757         VK_NULL_FUNC_ENTRY(vkCmdEndDebugUtilsLabelEXT,                                                  cmdEndDebugUtilsLabelEXT),
3758         VK_NULL_FUNC_ENTRY(vkCmdInsertDebugUtilsLabelEXT,                                               cmdInsertDebugUtilsLabelEXT),
3759         VK_NULL_FUNC_ENTRY(vkCmdSetSampleLocationsEXT,                                                  cmdSetSampleLocationsEXT),
3760         VK_NULL_FUNC_ENTRY(vkGetImageDrmFormatModifierPropertiesEXT,                    getImageDrmFormatModifierPropertiesEXT),
3761         VK_NULL_FUNC_ENTRY(vkCreateValidationCacheEXT,                                                  createValidationCacheEXT),
3762         VK_NULL_FUNC_ENTRY(vkDestroyValidationCacheEXT,                                                 destroyValidationCacheEXT),
3763         VK_NULL_FUNC_ENTRY(vkMergeValidationCachesEXT,                                                  mergeValidationCachesEXT),
3764         VK_NULL_FUNC_ENTRY(vkGetValidationCacheDataEXT,                                                 getValidationCacheDataEXT),
3765         VK_NULL_FUNC_ENTRY(vkCmdBindShadingRateImageNV,                                                 cmdBindShadingRateImageNV),
3766         VK_NULL_FUNC_ENTRY(vkCmdSetViewportShadingRatePaletteNV,                                cmdSetViewportShadingRatePaletteNV),
3767         VK_NULL_FUNC_ENTRY(vkCmdSetCoarseSampleOrderNV,                                                 cmdSetCoarseSampleOrderNV),
3768         VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureNV,                                             createAccelerationStructureNV),
3769         VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureNV,                                    destroyAccelerationStructureNV),
3770         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureMemoryRequirementsNV,              getAccelerationStructureMemoryRequirementsNV),
3771         VK_NULL_FUNC_ENTRY(vkBindAccelerationStructureMemoryNV,                                 bindAccelerationStructureMemoryNV),
3772         VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructureNV,                                   cmdBuildAccelerationStructureNV),
3773         VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureNV,                                    cmdCopyAccelerationStructureNV),
3774         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysNV,                                                                    cmdTraceRaysNV),
3775         VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesNV,                                               createRayTracingPipelinesNV),
3776         VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupHandlesKHR,                                getRayTracingShaderGroupHandlesKHR),
3777         VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupHandlesNV,                                 getRayTracingShaderGroupHandlesNV),
3778         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureHandleNV,                                  getAccelerationStructureHandleNV),
3779         VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesNV,                cmdWriteAccelerationStructuresPropertiesNV),
3780         VK_NULL_FUNC_ENTRY(vkCompileDeferredNV,                                                                 compileDeferredNV),
3781         VK_NULL_FUNC_ENTRY(vkGetMemoryHostPointerPropertiesEXT,                                 getMemoryHostPointerPropertiesEXT),
3782         VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarkerAMD,                                                   cmdWriteBufferMarkerAMD),
3783         VK_NULL_FUNC_ENTRY(vkGetCalibratedTimestampsEXT,                                                getCalibratedTimestampsEXT),
3784         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksNV,                                                                cmdDrawMeshTasksNV),
3785         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectNV,                                                cmdDrawMeshTasksIndirectNV),
3786         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectCountNV,                                   cmdDrawMeshTasksIndirectCountNV),
3787         VK_NULL_FUNC_ENTRY(vkCmdSetExclusiveScissorNV,                                                  cmdSetExclusiveScissorNV),
3788         VK_NULL_FUNC_ENTRY(vkCmdSetCheckpointNV,                                                                cmdSetCheckpointNV),
3789         VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointDataNV,                                                  getQueueCheckpointDataNV),
3790         VK_NULL_FUNC_ENTRY(vkInitializePerformanceApiINTEL,                                             initializePerformanceApiINTEL),
3791         VK_NULL_FUNC_ENTRY(vkUninitializePerformanceApiINTEL,                                   uninitializePerformanceApiINTEL),
3792         VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceMarkerINTEL,                                              cmdSetPerformanceMarkerINTEL),
3793         VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceStreamMarkerINTEL,                                cmdSetPerformanceStreamMarkerINTEL),
3794         VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceOverrideINTEL,                                    cmdSetPerformanceOverrideINTEL),
3795         VK_NULL_FUNC_ENTRY(vkAcquirePerformanceConfigurationINTEL,                              acquirePerformanceConfigurationINTEL),
3796         VK_NULL_FUNC_ENTRY(vkReleasePerformanceConfigurationINTEL,                              releasePerformanceConfigurationINTEL),
3797         VK_NULL_FUNC_ENTRY(vkQueueSetPerformanceConfigurationINTEL,                             queueSetPerformanceConfigurationINTEL),
3798         VK_NULL_FUNC_ENTRY(vkGetPerformanceParameterINTEL,                                              getPerformanceParameterINTEL),
3799         VK_NULL_FUNC_ENTRY(vkSetLocalDimmingAMD,                                                                setLocalDimmingAMD),
3800         VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddressEXT,                                                 getBufferDeviceAddressEXT),
3801         VK_NULL_FUNC_ENTRY(vkCmdSetLineStippleEXT,                                                              cmdSetLineStippleEXT),
3802         VK_NULL_FUNC_ENTRY(vkResetQueryPoolEXT,                                                                 resetQueryPool),
3803         VK_NULL_FUNC_ENTRY(vkCmdSetCullModeEXT,                                                                 cmdSetCullMode),
3804         VK_NULL_FUNC_ENTRY(vkCmdSetFrontFaceEXT,                                                                cmdSetFrontFace),
3805         VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveTopologyEXT,                                                cmdSetPrimitiveTopology),
3806         VK_NULL_FUNC_ENTRY(vkCmdSetViewportWithCountEXT,                                                cmdSetViewportWithCount),
3807         VK_NULL_FUNC_ENTRY(vkCmdSetScissorWithCountEXT,                                                 cmdSetScissorWithCount),
3808         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers2EXT,                                                  cmdBindVertexBuffers2),
3809         VK_NULL_FUNC_ENTRY(vkCmdSetDepthTestEnableEXT,                                                  cmdSetDepthTestEnable),
3810         VK_NULL_FUNC_ENTRY(vkCmdSetDepthWriteEnableEXT,                                                 cmdSetDepthWriteEnable),
3811         VK_NULL_FUNC_ENTRY(vkCmdSetDepthCompareOpEXT,                                                   cmdSetDepthCompareOp),
3812         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBoundsTestEnableEXT,                                    cmdSetDepthBoundsTestEnable),
3813         VK_NULL_FUNC_ENTRY(vkCmdSetStencilTestEnableEXT,                                                cmdSetStencilTestEnable),
3814         VK_NULL_FUNC_ENTRY(vkCmdSetStencilOpEXT,                                                                cmdSetStencilOp),
3815         VK_NULL_FUNC_ENTRY(vkGetGeneratedCommandsMemoryRequirementsNV,                  getGeneratedCommandsMemoryRequirementsNV),
3816         VK_NULL_FUNC_ENTRY(vkCmdPreprocessGeneratedCommandsNV,                                  cmdPreprocessGeneratedCommandsNV),
3817         VK_NULL_FUNC_ENTRY(vkCmdExecuteGeneratedCommandsNV,                                             cmdExecuteGeneratedCommandsNV),
3818         VK_NULL_FUNC_ENTRY(vkCmdBindPipelineShaderGroupNV,                                              cmdBindPipelineShaderGroupNV),
3819         VK_NULL_FUNC_ENTRY(vkCreateIndirectCommandsLayoutNV,                                    createIndirectCommandsLayoutNV),
3820         VK_NULL_FUNC_ENTRY(vkDestroyIndirectCommandsLayoutNV,                                   destroyIndirectCommandsLayoutNV),
3821         VK_NULL_FUNC_ENTRY(vkCreatePrivateDataSlotEXT,                                                  createPrivateDataSlot),
3822         VK_NULL_FUNC_ENTRY(vkDestroyPrivateDataSlotEXT,                                                 destroyPrivateDataSlot),
3823         VK_NULL_FUNC_ENTRY(vkSetPrivateDataEXT,                                                                 setPrivateData),
3824         VK_NULL_FUNC_ENTRY(vkGetPrivateDataEXT,                                                                 getPrivateData),
3825         VK_NULL_FUNC_ENTRY(vkCmdSetFragmentShadingRateEnumNV,                                   cmdSetFragmentShadingRateEnumNV),
3826         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout2EXT,                                             getImageSubresourceLayout2EXT),
3827         VK_NULL_FUNC_ENTRY(vkCmdSetVertexInputEXT,                                                              cmdSetVertexInputEXT),
3828         VK_NULL_FUNC_ENTRY(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,             getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI),
3829         VK_NULL_FUNC_ENTRY(vkCmdSubpassShadingHUAWEI,                                                   cmdSubpassShadingHUAWEI),
3830         VK_NULL_FUNC_ENTRY(vkCmdBindInvocationMaskHUAWEI,                                               cmdBindInvocationMaskHUAWEI),
3831         VK_NULL_FUNC_ENTRY(vkGetMemoryRemoteAddressNV,                                                  getMemoryRemoteAddressNV),
3832         VK_NULL_FUNC_ENTRY(vkGetPipelinePropertiesEXT,                                                  getPipelinePropertiesEXT),
3833         VK_NULL_FUNC_ENTRY(vkCmdSetPatchControlPointsEXT,                                               cmdSetPatchControlPointsEXT),
3834         VK_NULL_FUNC_ENTRY(vkCmdSetRasterizerDiscardEnableEXT,                                  cmdSetRasterizerDiscardEnable),
3835         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBiasEnableEXT,                                                  cmdSetDepthBiasEnable),
3836         VK_NULL_FUNC_ENTRY(vkCmdSetLogicOpEXT,                                                                  cmdSetLogicOpEXT),
3837         VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveRestartEnableEXT,                                   cmdSetPrimitiveRestartEnable),
3838         VK_NULL_FUNC_ENTRY(vkCmdSetColorWriteEnableEXT,                                                 cmdSetColorWriteEnableEXT),
3839         VK_NULL_FUNC_ENTRY(vkCmdDrawMultiEXT,                                                                   cmdDrawMultiEXT),
3840         VK_NULL_FUNC_ENTRY(vkCmdDrawMultiIndexedEXT,                                                    cmdDrawMultiIndexedEXT),
3841         VK_NULL_FUNC_ENTRY(vkSetDeviceMemoryPriorityEXT,                                                setDeviceMemoryPriorityEXT),
3842         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutHostMappingInfoVALVE,                getDescriptorSetLayoutHostMappingInfoVALVE),
3843         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetHostMappingVALVE,                                  getDescriptorSetHostMappingVALVE),
3844         VK_NULL_FUNC_ENTRY(vkGetShaderModuleIdentifierEXT,                                              getShaderModuleIdentifierEXT),
3845         VK_NULL_FUNC_ENTRY(vkGetShaderModuleCreateInfoIdentifierEXT,                    getShaderModuleCreateInfoIdentifierEXT),
3846         VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureKHR,                                    createAccelerationStructureKHR),
3847         VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureKHR,                                   destroyAccelerationStructureKHR),
3848         VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructuresKHR,                                 cmdBuildAccelerationStructuresKHR),
3849         VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructuresIndirectKHR,                 cmdBuildAccelerationStructuresIndirectKHR),
3850         VK_NULL_FUNC_ENTRY(vkBuildAccelerationStructuresKHR,                                    buildAccelerationStructuresKHR),
3851         VK_NULL_FUNC_ENTRY(vkCopyAccelerationStructureKHR,                                              copyAccelerationStructureKHR),
3852         VK_NULL_FUNC_ENTRY(vkCopyAccelerationStructureToMemoryKHR,                              copyAccelerationStructureToMemoryKHR),
3853         VK_NULL_FUNC_ENTRY(vkCopyMemoryToAccelerationStructureKHR,                              copyMemoryToAccelerationStructureKHR),
3854         VK_NULL_FUNC_ENTRY(vkWriteAccelerationStructuresPropertiesKHR,                  writeAccelerationStructuresPropertiesKHR),
3855         VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureKHR,                                   cmdCopyAccelerationStructureKHR),
3856         VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureToMemoryKHR,                   cmdCopyAccelerationStructureToMemoryKHR),
3857         VK_NULL_FUNC_ENTRY(vkCmdCopyMemoryToAccelerationStructureKHR,                   cmdCopyMemoryToAccelerationStructureKHR),
3858         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureDeviceAddressKHR,                  getAccelerationStructureDeviceAddressKHR),
3859         VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesKHR,               cmdWriteAccelerationStructuresPropertiesKHR),
3860         VK_NULL_FUNC_ENTRY(vkGetDeviceAccelerationStructureCompatibilityKHR,    getDeviceAccelerationStructureCompatibilityKHR),
3861         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureBuildSizesKHR,                             getAccelerationStructureBuildSizesKHR),
3862         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysKHR,                                                                   cmdTraceRaysKHR),
3863         VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesKHR,                                              createRayTracingPipelinesKHR),
3864         VK_NULL_FUNC_ENTRY(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,   getRayTracingCaptureReplayShaderGroupHandlesKHR),
3865         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysIndirectKHR,                                                   cmdTraceRaysIndirectKHR),
3866         VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupStackSizeKHR,                              getRayTracingShaderGroupStackSizeKHR),
3867         VK_NULL_FUNC_ENTRY(vkCmdSetRayTracingPipelineStackSizeKHR,                              cmdSetRayTracingPipelineStackSizeKHR),
3868         VK_NULL_FUNC_ENTRY(vkGetAndroidHardwareBufferPropertiesANDROID,                 getAndroidHardwareBufferPropertiesANDROID),
3869         VK_NULL_FUNC_ENTRY(vkGetMemoryAndroidHardwareBufferANDROID,                             getMemoryAndroidHardwareBufferANDROID),
3870         VK_NULL_FUNC_ENTRY(vkCreateVideoSessionKHR,                                                             createVideoSessionKHR),
3871         VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionKHR,                                                    destroyVideoSessionKHR),
3872         VK_NULL_FUNC_ENTRY(vkGetVideoSessionMemoryRequirementsKHR,                              getVideoSessionMemoryRequirementsKHR),
3873         VK_NULL_FUNC_ENTRY(vkBindVideoSessionMemoryKHR,                                                 bindVideoSessionMemoryKHR),
3874         VK_NULL_FUNC_ENTRY(vkCreateVideoSessionParametersKHR,                                   createVideoSessionParametersKHR),
3875         VK_NULL_FUNC_ENTRY(vkUpdateVideoSessionParametersKHR,                                   updateVideoSessionParametersKHR),
3876         VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionParametersKHR,                                  destroyVideoSessionParametersKHR),
3877         VK_NULL_FUNC_ENTRY(vkCmdBeginVideoCodingKHR,                                                    cmdBeginVideoCodingKHR),
3878         VK_NULL_FUNC_ENTRY(vkCmdEndVideoCodingKHR,                                                              cmdEndVideoCodingKHR),
3879         VK_NULL_FUNC_ENTRY(vkCmdControlVideoCodingKHR,                                                  cmdControlVideoCodingKHR),
3880         VK_NULL_FUNC_ENTRY(vkCmdDecodeVideoKHR,                                                                 cmdDecodeVideoKHR),
3881         VK_NULL_FUNC_ENTRY(vkCmdEncodeVideoKHR,                                                                 cmdEncodeVideoKHR),
3882         VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandleFUCHSIA,                                              getMemoryZirconHandleFUCHSIA),
3883         VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandlePropertiesFUCHSIA,                    getMemoryZirconHandlePropertiesFUCHSIA),
3884         VK_NULL_FUNC_ENTRY(vkImportSemaphoreZirconHandleFUCHSIA,                                importSemaphoreZirconHandleFUCHSIA),
3885         VK_NULL_FUNC_ENTRY(vkGetSemaphoreZirconHandleFUCHSIA,                                   getSemaphoreZirconHandleFUCHSIA),
3886         VK_NULL_FUNC_ENTRY(vkCreateBufferCollectionFUCHSIA,                                             createBufferCollectionFUCHSIA),
3887         VK_NULL_FUNC_ENTRY(vkSetBufferCollectionImageConstraintsFUCHSIA,                setBufferCollectionImageConstraintsFUCHSIA),
3888         VK_NULL_FUNC_ENTRY(vkSetBufferCollectionBufferConstraintsFUCHSIA,               setBufferCollectionBufferConstraintsFUCHSIA),
3889         VK_NULL_FUNC_ENTRY(vkDestroyBufferCollectionFUCHSIA,                                    destroyBufferCollectionFUCHSIA),
3890         VK_NULL_FUNC_ENTRY(vkGetBufferCollectionPropertiesFUCHSIA,                              getBufferCollectionPropertiesFUCHSIA),
3891         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHR,                                                   getMemoryWin32HandleKHR),
3892         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHR,                                 getMemoryWin32HandlePropertiesKHR),
3893         VK_NULL_FUNC_ENTRY(vkImportSemaphoreWin32HandleKHR,                                             importSemaphoreWin32HandleKHR),
3894         VK_NULL_FUNC_ENTRY(vkGetSemaphoreWin32HandleKHR,                                                getSemaphoreWin32HandleKHR),
3895         VK_NULL_FUNC_ENTRY(vkImportFenceWin32HandleKHR,                                                 importFenceWin32HandleKHR),
3896         VK_NULL_FUNC_ENTRY(vkGetFenceWin32HandleKHR,                                                    getFenceWin32HandleKHR),
3897         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleNV,                                                    getMemoryWin32HandleNV),
3898         VK_NULL_FUNC_ENTRY(vkAcquireFullScreenExclusiveModeEXT,                                 acquireFullScreenExclusiveModeEXT),
3899         VK_NULL_FUNC_ENTRY(vkReleaseFullScreenExclusiveModeEXT,                                 releaseFullScreenExclusiveModeEXT),
3900         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModes2EXT,                             getDeviceGroupSurfacePresentModes2EXT),
3901 };
3902