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