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 VkResult VKAPI_CALL waitForPresentKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
1705 {
1706         DE_UNREF(device);
1707         DE_UNREF(swapchain);
1708         DE_UNREF(presentId);
1709         DE_UNREF(timeout);
1710         return VK_SUCCESS;
1711 }
1712
1713 VKAPI_ATTR uint32_t VKAPI_CALL getDeferredOperationMaxConcurrencyKHR (VkDevice device, VkDeferredOperationKHR operation)
1714 {
1715         DE_UNREF(device);
1716         DE_UNREF(operation);
1717         return VK_SUCCESS;
1718 }
1719
1720 VKAPI_ATTR VkResult VKAPI_CALL getDeferredOperationResultKHR (VkDevice device, VkDeferredOperationKHR operation)
1721 {
1722         DE_UNREF(device);
1723         DE_UNREF(operation);
1724         return VK_SUCCESS;
1725 }
1726
1727 VKAPI_ATTR VkResult VKAPI_CALL deferredOperationJoinKHR (VkDevice device, VkDeferredOperationKHR operation)
1728 {
1729         DE_UNREF(device);
1730         DE_UNREF(operation);
1731         return VK_SUCCESS;
1732 }
1733
1734 VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties)
1735 {
1736         DE_UNREF(device);
1737         DE_UNREF(pPipelineInfo);
1738         DE_UNREF(pExecutableCount);
1739         DE_UNREF(pProperties);
1740         return VK_SUCCESS;
1741 }
1742
1743 VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics)
1744 {
1745         DE_UNREF(device);
1746         DE_UNREF(pExecutableInfo);
1747         DE_UNREF(pStatisticCount);
1748         DE_UNREF(pStatistics);
1749         return VK_SUCCESS;
1750 }
1751
1752 VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
1753 {
1754         DE_UNREF(device);
1755         DE_UNREF(pExecutableInfo);
1756         DE_UNREF(pInternalRepresentationCount);
1757         DE_UNREF(pInternalRepresentations);
1758         return VK_SUCCESS;
1759 }
1760
1761 VKAPI_ATTR void VKAPI_CALL cmdSetEvent2KHR (VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo)
1762 {
1763         DE_UNREF(commandBuffer);
1764         DE_UNREF(event);
1765         DE_UNREF(pDependencyInfo);
1766 }
1767
1768 VKAPI_ATTR void VKAPI_CALL cmdResetEvent2KHR (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask)
1769 {
1770         DE_UNREF(commandBuffer);
1771         DE_UNREF(event);
1772         DE_UNREF(stageMask);
1773 }
1774
1775 VKAPI_ATTR void VKAPI_CALL cmdWaitEvents2KHR (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfos)
1776 {
1777         DE_UNREF(commandBuffer);
1778         DE_UNREF(eventCount);
1779         DE_UNREF(pEvents);
1780         DE_UNREF(pDependencyInfos);
1781 }
1782
1783 VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier2KHR (VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo)
1784 {
1785         DE_UNREF(commandBuffer);
1786         DE_UNREF(pDependencyInfo);
1787 }
1788
1789 VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp2KHR (VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query)
1790 {
1791         DE_UNREF(commandBuffer);
1792         DE_UNREF(stage);
1793         DE_UNREF(queryPool);
1794         DE_UNREF(query);
1795 }
1796
1797 VKAPI_ATTR VkResult VKAPI_CALL queueSubmit2KHR (VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence)
1798 {
1799         DE_UNREF(queue);
1800         DE_UNREF(submitCount);
1801         DE_UNREF(pSubmits);
1802         DE_UNREF(fence);
1803         return VK_SUCCESS;
1804 }
1805
1806 VKAPI_ATTR void VKAPI_CALL cmdWriteBufferMarker2AMD (VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
1807 {
1808         DE_UNREF(commandBuffer);
1809         DE_UNREF(stage);
1810         DE_UNREF(dstBuffer);
1811         DE_UNREF(dstOffset);
1812         DE_UNREF(marker);
1813 }
1814
1815 VKAPI_ATTR void VKAPI_CALL getQueueCheckpointData2NV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData)
1816 {
1817         DE_UNREF(queue);
1818         DE_UNREF(pCheckpointDataCount);
1819         DE_UNREF(pCheckpointData);
1820 }
1821
1822 VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer2KHR (VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo)
1823 {
1824         DE_UNREF(commandBuffer);
1825         DE_UNREF(pCopyBufferInfo);
1826 }
1827
1828 VKAPI_ATTR void VKAPI_CALL cmdCopyImage2KHR (VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo)
1829 {
1830         DE_UNREF(commandBuffer);
1831         DE_UNREF(pCopyImageInfo);
1832 }
1833
1834 VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage2KHR (VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo)
1835 {
1836         DE_UNREF(commandBuffer);
1837         DE_UNREF(pCopyBufferToImageInfo);
1838 }
1839
1840 VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer2KHR (VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo)
1841 {
1842         DE_UNREF(commandBuffer);
1843         DE_UNREF(pCopyImageToBufferInfo);
1844 }
1845
1846 VKAPI_ATTR void VKAPI_CALL cmdBlitImage2KHR (VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo)
1847 {
1848         DE_UNREF(commandBuffer);
1849         DE_UNREF(pBlitImageInfo);
1850 }
1851
1852 VKAPI_ATTR void VKAPI_CALL cmdResolveImage2KHR (VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo)
1853 {
1854         DE_UNREF(commandBuffer);
1855         DE_UNREF(pResolveImageInfo);
1856 }
1857
1858 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)
1859 {
1860         DE_UNREF(instance);
1861         DE_UNREF(flags);
1862         DE_UNREF(objectType);
1863         DE_UNREF(object);
1864         DE_UNREF(location);
1865         DE_UNREF(messageCode);
1866         DE_UNREF(pLayerPrefix);
1867         DE_UNREF(pMessage);
1868 }
1869
1870 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
1871 {
1872         DE_UNREF(device);
1873         DE_UNREF(pTagInfo);
1874         return VK_SUCCESS;
1875 }
1876
1877 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
1878 {
1879         DE_UNREF(device);
1880         DE_UNREF(pNameInfo);
1881         return VK_SUCCESS;
1882 }
1883
1884 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
1885 {
1886         DE_UNREF(commandBuffer);
1887         DE_UNREF(pMarkerInfo);
1888 }
1889
1890 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer)
1891 {
1892         DE_UNREF(commandBuffer);
1893 }
1894
1895 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
1896 {
1897         DE_UNREF(commandBuffer);
1898         DE_UNREF(pMarkerInfo);
1899 }
1900
1901 VKAPI_ATTR void VKAPI_CALL cmdBindTransformFeedbackBuffersEXT (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
1902 {
1903         DE_UNREF(commandBuffer);
1904         DE_UNREF(firstBinding);
1905         DE_UNREF(bindingCount);
1906         DE_UNREF(pBuffers);
1907         DE_UNREF(pOffsets);
1908         DE_UNREF(pSizes);
1909 }
1910
1911 VKAPI_ATTR void VKAPI_CALL cmdBeginTransformFeedbackEXT (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 cmdEndTransformFeedbackEXT (VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
1921 {
1922         DE_UNREF(commandBuffer);
1923         DE_UNREF(firstCounterBuffer);
1924         DE_UNREF(counterBufferCount);
1925         DE_UNREF(pCounterBuffers);
1926         DE_UNREF(pCounterBufferOffsets);
1927 }
1928
1929 VKAPI_ATTR void VKAPI_CALL cmdBeginQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
1930 {
1931         DE_UNREF(commandBuffer);
1932         DE_UNREF(queryPool);
1933         DE_UNREF(query);
1934         DE_UNREF(flags);
1935         DE_UNREF(index);
1936 }
1937
1938 VKAPI_ATTR void VKAPI_CALL cmdEndQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
1939 {
1940         DE_UNREF(commandBuffer);
1941         DE_UNREF(queryPool);
1942         DE_UNREF(query);
1943         DE_UNREF(index);
1944 }
1945
1946 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectByteCountEXT (VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
1947 {
1948         DE_UNREF(commandBuffer);
1949         DE_UNREF(instanceCount);
1950         DE_UNREF(firstInstance);
1951         DE_UNREF(counterBuffer);
1952         DE_UNREF(counterBufferOffset);
1953         DE_UNREF(counterOffset);
1954         DE_UNREF(vertexStride);
1955 }
1956
1957 VKAPI_ATTR void VKAPI_CALL cmdCuLaunchKernelNVX (VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo)
1958 {
1959         DE_UNREF(commandBuffer);
1960         DE_UNREF(pLaunchInfo);
1961 }
1962
1963 VKAPI_ATTR uint32_t VKAPI_CALL getImageViewHandleNVX (VkDevice device, const VkImageViewHandleInfoNVX* pInfo)
1964 {
1965         DE_UNREF(device);
1966         DE_UNREF(pInfo);
1967         return VK_SUCCESS;
1968 }
1969
1970 VKAPI_ATTR VkResult VKAPI_CALL getImageViewAddressNVX (VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties)
1971 {
1972         DE_UNREF(device);
1973         DE_UNREF(imageView);
1974         DE_UNREF(pProperties);
1975         return VK_SUCCESS;
1976 }
1977
1978 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1979 {
1980         DE_UNREF(commandBuffer);
1981         DE_UNREF(buffer);
1982         DE_UNREF(offset);
1983         DE_UNREF(countBuffer);
1984         DE_UNREF(countBufferOffset);
1985         DE_UNREF(maxDrawCount);
1986         DE_UNREF(stride);
1987 }
1988
1989 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1990 {
1991         DE_UNREF(commandBuffer);
1992         DE_UNREF(buffer);
1993         DE_UNREF(offset);
1994         DE_UNREF(countBuffer);
1995         DE_UNREF(countBufferOffset);
1996         DE_UNREF(maxDrawCount);
1997         DE_UNREF(stride);
1998 }
1999
2000 VKAPI_ATTR VkResult VKAPI_CALL getShaderInfoAMD (VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo)
2001 {
2002         DE_UNREF(device);
2003         DE_UNREF(pipeline);
2004         DE_UNREF(shaderStage);
2005         DE_UNREF(infoType);
2006         DE_UNREF(pInfoSize);
2007         DE_UNREF(pInfo);
2008         return VK_SUCCESS;
2009 }
2010
2011 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
2012 {
2013         DE_UNREF(physicalDevice);
2014         DE_UNREF(format);
2015         DE_UNREF(type);
2016         DE_UNREF(tiling);
2017         DE_UNREF(usage);
2018         DE_UNREF(flags);
2019         DE_UNREF(externalHandleType);
2020         DE_UNREF(pExternalImageFormatProperties);
2021         return VK_SUCCESS;
2022 }
2023
2024 VKAPI_ATTR void VKAPI_CALL cmdBeginConditionalRenderingEXT (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
2025 {
2026         DE_UNREF(commandBuffer);
2027         DE_UNREF(pConditionalRenderingBegin);
2028 }
2029
2030 VKAPI_ATTR void VKAPI_CALL cmdEndConditionalRenderingEXT (VkCommandBuffer commandBuffer)
2031 {
2032         DE_UNREF(commandBuffer);
2033 }
2034
2035 VKAPI_ATTR void VKAPI_CALL cmdSetViewportWScalingNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings)
2036 {
2037         DE_UNREF(commandBuffer);
2038         DE_UNREF(firstViewport);
2039         DE_UNREF(viewportCount);
2040         DE_UNREF(pViewportWScalings);
2041 }
2042
2043 VKAPI_ATTR VkResult VKAPI_CALL releaseDisplayEXT (VkPhysicalDevice physicalDevice, VkDisplayKHR display)
2044 {
2045         DE_UNREF(physicalDevice);
2046         DE_UNREF(display);
2047         return VK_SUCCESS;
2048 }
2049
2050 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2EXT (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
2051 {
2052         DE_UNREF(physicalDevice);
2053         DE_UNREF(surface);
2054         DE_UNREF(pSurfaceCapabilities);
2055         return VK_SUCCESS;
2056 }
2057
2058 VKAPI_ATTR VkResult VKAPI_CALL displayPowerControlEXT (VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
2059 {
2060         DE_UNREF(device);
2061         DE_UNREF(display);
2062         DE_UNREF(pDisplayPowerInfo);
2063         return VK_SUCCESS;
2064 }
2065
2066 VKAPI_ATTR VkResult VKAPI_CALL registerDeviceEventEXT (VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
2067 {
2068         DE_UNREF(device);
2069         DE_UNREF(pDeviceEventInfo);
2070         DE_UNREF(pAllocator);
2071         DE_UNREF(pFence);
2072         return VK_SUCCESS;
2073 }
2074
2075 VKAPI_ATTR VkResult VKAPI_CALL registerDisplayEventEXT (VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
2076 {
2077         DE_UNREF(device);
2078         DE_UNREF(display);
2079         DE_UNREF(pDisplayEventInfo);
2080         DE_UNREF(pAllocator);
2081         DE_UNREF(pFence);
2082         return VK_SUCCESS;
2083 }
2084
2085 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainCounterEXT (VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue)
2086 {
2087         DE_UNREF(device);
2088         DE_UNREF(swapchain);
2089         DE_UNREF(counter);
2090         DE_UNREF(pCounterValue);
2091         return VK_SUCCESS;
2092 }
2093
2094 VKAPI_ATTR VkResult VKAPI_CALL getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
2095 {
2096         DE_UNREF(device);
2097         DE_UNREF(swapchain);
2098         DE_UNREF(pDisplayTimingProperties);
2099         return VK_SUCCESS;
2100 }
2101
2102 VKAPI_ATTR VkResult VKAPI_CALL getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings)
2103 {
2104         DE_UNREF(device);
2105         DE_UNREF(swapchain);
2106         DE_UNREF(pPresentationTimingCount);
2107         DE_UNREF(pPresentationTimings);
2108         return VK_SUCCESS;
2109 }
2110
2111 VKAPI_ATTR void VKAPI_CALL cmdSetDiscardRectangleEXT (VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles)
2112 {
2113         DE_UNREF(commandBuffer);
2114         DE_UNREF(firstDiscardRectangle);
2115         DE_UNREF(discardRectangleCount);
2116         DE_UNREF(pDiscardRectangles);
2117 }
2118
2119 VKAPI_ATTR void VKAPI_CALL setHdrMetadataEXT (VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata)
2120 {
2121         DE_UNREF(device);
2122         DE_UNREF(swapchainCount);
2123         DE_UNREF(pSwapchains);
2124         DE_UNREF(pMetadata);
2125 }
2126
2127 VKAPI_ATTR VkResult VKAPI_CALL setDebugUtilsObjectNameEXT (VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
2128 {
2129         DE_UNREF(device);
2130         DE_UNREF(pNameInfo);
2131         return VK_SUCCESS;
2132 }
2133
2134 VKAPI_ATTR VkResult VKAPI_CALL setDebugUtilsObjectTagEXT (VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
2135 {
2136         DE_UNREF(device);
2137         DE_UNREF(pTagInfo);
2138         return VK_SUCCESS;
2139 }
2140
2141 VKAPI_ATTR void VKAPI_CALL queueBeginDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
2142 {
2143         DE_UNREF(queue);
2144         DE_UNREF(pLabelInfo);
2145 }
2146
2147 VKAPI_ATTR void VKAPI_CALL queueEndDebugUtilsLabelEXT (VkQueue queue)
2148 {
2149         DE_UNREF(queue);
2150 }
2151
2152 VKAPI_ATTR void VKAPI_CALL queueInsertDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
2153 {
2154         DE_UNREF(queue);
2155         DE_UNREF(pLabelInfo);
2156 }
2157
2158 VKAPI_ATTR void VKAPI_CALL cmdBeginDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
2159 {
2160         DE_UNREF(commandBuffer);
2161         DE_UNREF(pLabelInfo);
2162 }
2163
2164 VKAPI_ATTR void VKAPI_CALL cmdEndDebugUtilsLabelEXT (VkCommandBuffer commandBuffer)
2165 {
2166         DE_UNREF(commandBuffer);
2167 }
2168
2169 VKAPI_ATTR void VKAPI_CALL cmdInsertDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
2170 {
2171         DE_UNREF(commandBuffer);
2172         DE_UNREF(pLabelInfo);
2173 }
2174
2175 VKAPI_ATTR void VKAPI_CALL submitDebugUtilsMessageEXT (VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
2176 {
2177         DE_UNREF(instance);
2178         DE_UNREF(messageSeverity);
2179         DE_UNREF(messageTypes);
2180         DE_UNREF(pCallbackData);
2181 }
2182
2183 VKAPI_ATTR void VKAPI_CALL cmdSetSampleLocationsEXT (VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
2184 {
2185         DE_UNREF(commandBuffer);
2186         DE_UNREF(pSampleLocationsInfo);
2187 }
2188
2189 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMultisamplePropertiesEXT (VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties)
2190 {
2191         DE_UNREF(physicalDevice);
2192         DE_UNREF(samples);
2193         DE_UNREF(pMultisampleProperties);
2194 }
2195
2196 VKAPI_ATTR VkResult VKAPI_CALL getImageDrmFormatModifierPropertiesEXT (VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
2197 {
2198         DE_UNREF(device);
2199         DE_UNREF(image);
2200         DE_UNREF(pProperties);
2201         return VK_SUCCESS;
2202 }
2203
2204 VKAPI_ATTR VkResult VKAPI_CALL mergeValidationCachesEXT (VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches)
2205 {
2206         DE_UNREF(device);
2207         DE_UNREF(dstCache);
2208         DE_UNREF(srcCacheCount);
2209         DE_UNREF(pSrcCaches);
2210         return VK_SUCCESS;
2211 }
2212
2213 VKAPI_ATTR VkResult VKAPI_CALL getValidationCacheDataEXT (VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData)
2214 {
2215         DE_UNREF(device);
2216         DE_UNREF(validationCache);
2217         DE_UNREF(pDataSize);
2218         DE_UNREF(pData);
2219         return VK_SUCCESS;
2220 }
2221
2222 VKAPI_ATTR void VKAPI_CALL cmdBindShadingRateImageNV (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
2223 {
2224         DE_UNREF(commandBuffer);
2225         DE_UNREF(imageView);
2226         DE_UNREF(imageLayout);
2227 }
2228
2229 VKAPI_ATTR void VKAPI_CALL cmdSetViewportShadingRatePaletteNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes)
2230 {
2231         DE_UNREF(commandBuffer);
2232         DE_UNREF(firstViewport);
2233         DE_UNREF(viewportCount);
2234         DE_UNREF(pShadingRatePalettes);
2235 }
2236
2237 VKAPI_ATTR void VKAPI_CALL cmdSetCoarseSampleOrderNV (VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders)
2238 {
2239         DE_UNREF(commandBuffer);
2240         DE_UNREF(sampleOrderType);
2241         DE_UNREF(customSampleOrderCount);
2242         DE_UNREF(pCustomSampleOrders);
2243 }
2244
2245 VKAPI_ATTR void VKAPI_CALL getAccelerationStructureMemoryRequirementsNV (VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
2246 {
2247         DE_UNREF(device);
2248         DE_UNREF(pInfo);
2249         DE_UNREF(pMemoryRequirements);
2250 }
2251
2252 VKAPI_ATTR VkResult VKAPI_CALL bindAccelerationStructureMemoryNV (VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos)
2253 {
2254         DE_UNREF(device);
2255         DE_UNREF(bindInfoCount);
2256         DE_UNREF(pBindInfos);
2257         return VK_SUCCESS;
2258 }
2259
2260 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)
2261 {
2262         DE_UNREF(commandBuffer);
2263         DE_UNREF(pInfo);
2264         DE_UNREF(instanceData);
2265         DE_UNREF(instanceOffset);
2266         DE_UNREF(update);
2267         DE_UNREF(dst);
2268         DE_UNREF(src);
2269         DE_UNREF(scratch);
2270         DE_UNREF(scratchOffset);
2271 }
2272
2273 VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureNV (VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
2274 {
2275         DE_UNREF(commandBuffer);
2276         DE_UNREF(dst);
2277         DE_UNREF(src);
2278         DE_UNREF(mode);
2279 }
2280
2281 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)
2282 {
2283         DE_UNREF(commandBuffer);
2284         DE_UNREF(raygenShaderBindingTableBuffer);
2285         DE_UNREF(raygenShaderBindingOffset);
2286         DE_UNREF(missShaderBindingTableBuffer);
2287         DE_UNREF(missShaderBindingOffset);
2288         DE_UNREF(missShaderBindingStride);
2289         DE_UNREF(hitShaderBindingTableBuffer);
2290         DE_UNREF(hitShaderBindingOffset);
2291         DE_UNREF(hitShaderBindingStride);
2292         DE_UNREF(callableShaderBindingTableBuffer);
2293         DE_UNREF(callableShaderBindingOffset);
2294         DE_UNREF(callableShaderBindingStride);
2295         DE_UNREF(width);
2296         DE_UNREF(height);
2297         DE_UNREF(depth);
2298 }
2299
2300 VKAPI_ATTR VkResult VKAPI_CALL getRayTracingShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
2301 {
2302         DE_UNREF(device);
2303         DE_UNREF(pipeline);
2304         DE_UNREF(firstGroup);
2305         DE_UNREF(groupCount);
2306         DE_UNREF(dataSize);
2307         DE_UNREF(pData);
2308         return VK_SUCCESS;
2309 }
2310
2311 VKAPI_ATTR VkResult VKAPI_CALL getRayTracingShaderGroupHandlesNV (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
2312 {
2313         DE_UNREF(device);
2314         DE_UNREF(pipeline);
2315         DE_UNREF(firstGroup);
2316         DE_UNREF(groupCount);
2317         DE_UNREF(dataSize);
2318         DE_UNREF(pData);
2319         return VK_SUCCESS;
2320 }
2321
2322 VKAPI_ATTR VkResult VKAPI_CALL getAccelerationStructureHandleNV (VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData)
2323 {
2324         DE_UNREF(device);
2325         DE_UNREF(accelerationStructure);
2326         DE_UNREF(dataSize);
2327         DE_UNREF(pData);
2328         return VK_SUCCESS;
2329 }
2330
2331 VKAPI_ATTR void VKAPI_CALL cmdWriteAccelerationStructuresPropertiesNV (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2332 {
2333         DE_UNREF(commandBuffer);
2334         DE_UNREF(accelerationStructureCount);
2335         DE_UNREF(pAccelerationStructures);
2336         DE_UNREF(queryType);
2337         DE_UNREF(queryPool);
2338         DE_UNREF(firstQuery);
2339 }
2340
2341 VKAPI_ATTR VkResult VKAPI_CALL compileDeferredNV (VkDevice device, VkPipeline pipeline, uint32_t shader)
2342 {
2343         DE_UNREF(device);
2344         DE_UNREF(pipeline);
2345         DE_UNREF(shader);
2346         return VK_SUCCESS;
2347 }
2348
2349 VKAPI_ATTR VkResult VKAPI_CALL getMemoryHostPointerPropertiesEXT (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
2350 {
2351         DE_UNREF(device);
2352         DE_UNREF(handleType);
2353         DE_UNREF(pHostPointer);
2354         DE_UNREF(pMemoryHostPointerProperties);
2355         return VK_SUCCESS;
2356 }
2357
2358 VKAPI_ATTR void VKAPI_CALL cmdWriteBufferMarkerAMD (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
2359 {
2360         DE_UNREF(commandBuffer);
2361         DE_UNREF(pipelineStage);
2362         DE_UNREF(dstBuffer);
2363         DE_UNREF(dstOffset);
2364         DE_UNREF(marker);
2365 }
2366
2367 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceCalibrateableTimeDomainsEXT (VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
2368 {
2369         DE_UNREF(physicalDevice);
2370         DE_UNREF(pTimeDomainCount);
2371         DE_UNREF(pTimeDomains);
2372         return VK_SUCCESS;
2373 }
2374
2375 VKAPI_ATTR VkResult VKAPI_CALL getCalibratedTimestampsEXT (VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
2376 {
2377         DE_UNREF(device);
2378         DE_UNREF(timestampCount);
2379         DE_UNREF(pTimestampInfos);
2380         DE_UNREF(pTimestamps);
2381         DE_UNREF(pMaxDeviation);
2382         return VK_SUCCESS;
2383 }
2384
2385 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksNV (VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
2386 {
2387         DE_UNREF(commandBuffer);
2388         DE_UNREF(taskCount);
2389         DE_UNREF(firstTask);
2390 }
2391
2392 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
2393 {
2394         DE_UNREF(commandBuffer);
2395         DE_UNREF(buffer);
2396         DE_UNREF(offset);
2397         DE_UNREF(drawCount);
2398         DE_UNREF(stride);
2399 }
2400
2401 VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectCountNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
2402 {
2403         DE_UNREF(commandBuffer);
2404         DE_UNREF(buffer);
2405         DE_UNREF(offset);
2406         DE_UNREF(countBuffer);
2407         DE_UNREF(countBufferOffset);
2408         DE_UNREF(maxDrawCount);
2409         DE_UNREF(stride);
2410 }
2411
2412 VKAPI_ATTR void VKAPI_CALL cmdSetExclusiveScissorNV (VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors)
2413 {
2414         DE_UNREF(commandBuffer);
2415         DE_UNREF(firstExclusiveScissor);
2416         DE_UNREF(exclusiveScissorCount);
2417         DE_UNREF(pExclusiveScissors);
2418 }
2419
2420 VKAPI_ATTR void VKAPI_CALL cmdSetCheckpointNV (VkCommandBuffer commandBuffer, const void* pCheckpointMarker)
2421 {
2422         DE_UNREF(commandBuffer);
2423         DE_UNREF(pCheckpointMarker);
2424 }
2425
2426 VKAPI_ATTR void VKAPI_CALL getQueueCheckpointDataNV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData)
2427 {
2428         DE_UNREF(queue);
2429         DE_UNREF(pCheckpointDataCount);
2430         DE_UNREF(pCheckpointData);
2431 }
2432
2433 VKAPI_ATTR VkResult VKAPI_CALL initializePerformanceApiINTEL (VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo)
2434 {
2435         DE_UNREF(device);
2436         DE_UNREF(pInitializeInfo);
2437         return VK_SUCCESS;
2438 }
2439
2440 VKAPI_ATTR void VKAPI_CALL uninitializePerformanceApiINTEL (VkDevice device)
2441 {
2442         DE_UNREF(device);
2443 }
2444
2445 VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo)
2446 {
2447         DE_UNREF(commandBuffer);
2448         DE_UNREF(pMarkerInfo);
2449         return VK_SUCCESS;
2450 }
2451
2452 VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceStreamMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo)
2453 {
2454         DE_UNREF(commandBuffer);
2455         DE_UNREF(pMarkerInfo);
2456         return VK_SUCCESS;
2457 }
2458
2459 VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceOverrideINTEL (VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo)
2460 {
2461         DE_UNREF(commandBuffer);
2462         DE_UNREF(pOverrideInfo);
2463         return VK_SUCCESS;
2464 }
2465
2466 VKAPI_ATTR VkResult VKAPI_CALL acquirePerformanceConfigurationINTEL (VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration)
2467 {
2468         DE_UNREF(device);
2469         DE_UNREF(pAcquireInfo);
2470         DE_UNREF(pConfiguration);
2471         return VK_SUCCESS;
2472 }
2473
2474 VKAPI_ATTR VkResult VKAPI_CALL releasePerformanceConfigurationINTEL (VkDevice device, VkPerformanceConfigurationINTEL configuration)
2475 {
2476         DE_UNREF(device);
2477         DE_UNREF(configuration);
2478         return VK_SUCCESS;
2479 }
2480
2481 VKAPI_ATTR VkResult VKAPI_CALL queueSetPerformanceConfigurationINTEL (VkQueue queue, VkPerformanceConfigurationINTEL configuration)
2482 {
2483         DE_UNREF(queue);
2484         DE_UNREF(configuration);
2485         return VK_SUCCESS;
2486 }
2487
2488 VKAPI_ATTR VkResult VKAPI_CALL getPerformanceParameterINTEL (VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue)
2489 {
2490         DE_UNREF(device);
2491         DE_UNREF(parameter);
2492         DE_UNREF(pValue);
2493         return VK_SUCCESS;
2494 }
2495
2496 VKAPI_ATTR void VKAPI_CALL setLocalDimmingAMD (VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
2497 {
2498         DE_UNREF(device);
2499         DE_UNREF(swapChain);
2500         DE_UNREF(localDimmingEnable);
2501 }
2502
2503 VKAPI_ATTR VkDeviceAddress VKAPI_CALL getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
2504 {
2505         DE_UNREF(device);
2506         DE_UNREF(pInfo);
2507         return VK_SUCCESS;
2508 }
2509
2510 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceToolPropertiesEXT (VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolPropertiesEXT* pToolProperties)
2511 {
2512         DE_UNREF(physicalDevice);
2513         DE_UNREF(pToolCount);
2514         DE_UNREF(pToolProperties);
2515         return VK_SUCCESS;
2516 }
2517
2518 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceCooperativeMatrixPropertiesNV (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties)
2519 {
2520         DE_UNREF(physicalDevice);
2521         DE_UNREF(pPropertyCount);
2522         DE_UNREF(pProperties);
2523         return VK_SUCCESS;
2524 }
2525
2526 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV (VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations)
2527 {
2528         DE_UNREF(physicalDevice);
2529         DE_UNREF(pCombinationCount);
2530         DE_UNREF(pCombinations);
2531         return VK_SUCCESS;
2532 }
2533
2534 VKAPI_ATTR void VKAPI_CALL cmdSetLineStippleEXT (VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
2535 {
2536         DE_UNREF(commandBuffer);
2537         DE_UNREF(lineStippleFactor);
2538         DE_UNREF(lineStipplePattern);
2539 }
2540
2541 VKAPI_ATTR void VKAPI_CALL cmdSetCullModeEXT (VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
2542 {
2543         DE_UNREF(commandBuffer);
2544         DE_UNREF(cullMode);
2545 }
2546
2547 VKAPI_ATTR void VKAPI_CALL cmdSetFrontFaceEXT (VkCommandBuffer commandBuffer, VkFrontFace frontFace)
2548 {
2549         DE_UNREF(commandBuffer);
2550         DE_UNREF(frontFace);
2551 }
2552
2553 VKAPI_ATTR void VKAPI_CALL cmdSetPrimitiveTopologyEXT (VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
2554 {
2555         DE_UNREF(commandBuffer);
2556         DE_UNREF(primitiveTopology);
2557 }
2558
2559 VKAPI_ATTR void VKAPI_CALL cmdSetViewportWithCountEXT (VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
2560 {
2561         DE_UNREF(commandBuffer);
2562         DE_UNREF(viewportCount);
2563         DE_UNREF(pViewports);
2564 }
2565
2566 VKAPI_ATTR void VKAPI_CALL cmdSetScissorWithCountEXT (VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
2567 {
2568         DE_UNREF(commandBuffer);
2569         DE_UNREF(scissorCount);
2570         DE_UNREF(pScissors);
2571 }
2572
2573 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)
2574 {
2575         DE_UNREF(commandBuffer);
2576         DE_UNREF(firstBinding);
2577         DE_UNREF(bindingCount);
2578         DE_UNREF(pBuffers);
2579         DE_UNREF(pOffsets);
2580         DE_UNREF(pSizes);
2581         DE_UNREF(pStrides);
2582 }
2583
2584 VKAPI_ATTR void VKAPI_CALL cmdSetDepthTestEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
2585 {
2586         DE_UNREF(commandBuffer);
2587         DE_UNREF(depthTestEnable);
2588 }
2589
2590 VKAPI_ATTR void VKAPI_CALL cmdSetDepthWriteEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
2591 {
2592         DE_UNREF(commandBuffer);
2593         DE_UNREF(depthWriteEnable);
2594 }
2595
2596 VKAPI_ATTR void VKAPI_CALL cmdSetDepthCompareOpEXT (VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
2597 {
2598         DE_UNREF(commandBuffer);
2599         DE_UNREF(depthCompareOp);
2600 }
2601
2602 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBoundsTestEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
2603 {
2604         DE_UNREF(commandBuffer);
2605         DE_UNREF(depthBoundsTestEnable);
2606 }
2607
2608 VKAPI_ATTR void VKAPI_CALL cmdSetStencilTestEnableEXT (VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
2609 {
2610         DE_UNREF(commandBuffer);
2611         DE_UNREF(stencilTestEnable);
2612 }
2613
2614 VKAPI_ATTR void VKAPI_CALL cmdSetStencilOpEXT (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
2615 {
2616         DE_UNREF(commandBuffer);
2617         DE_UNREF(faceMask);
2618         DE_UNREF(failOp);
2619         DE_UNREF(passOp);
2620         DE_UNREF(depthFailOp);
2621         DE_UNREF(compareOp);
2622 }
2623
2624 VKAPI_ATTR void VKAPI_CALL getGeneratedCommandsMemoryRequirementsNV (VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements)
2625 {
2626         DE_UNREF(device);
2627         DE_UNREF(pInfo);
2628         DE_UNREF(pMemoryRequirements);
2629 }
2630
2631 VKAPI_ATTR void VKAPI_CALL cmdPreprocessGeneratedCommandsNV (VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
2632 {
2633         DE_UNREF(commandBuffer);
2634         DE_UNREF(pGeneratedCommandsInfo);
2635 }
2636
2637 VKAPI_ATTR void VKAPI_CALL cmdExecuteGeneratedCommandsNV (VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
2638 {
2639         DE_UNREF(commandBuffer);
2640         DE_UNREF(isPreprocessed);
2641         DE_UNREF(pGeneratedCommandsInfo);
2642 }
2643
2644 VKAPI_ATTR void VKAPI_CALL cmdBindPipelineShaderGroupNV (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
2645 {
2646         DE_UNREF(commandBuffer);
2647         DE_UNREF(pipelineBindPoint);
2648         DE_UNREF(pipeline);
2649         DE_UNREF(groupIndex);
2650 }
2651
2652 VKAPI_ATTR VkResult VKAPI_CALL acquireDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
2653 {
2654         DE_UNREF(physicalDevice);
2655         DE_UNREF(drmFd);
2656         DE_UNREF(display);
2657         return VK_SUCCESS;
2658 }
2659
2660 VKAPI_ATTR VkResult VKAPI_CALL getDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display)
2661 {
2662         DE_UNREF(physicalDevice);
2663         DE_UNREF(drmFd);
2664         DE_UNREF(connectorId);
2665         DE_UNREF(display);
2666         return VK_SUCCESS;
2667 }
2668
2669 VKAPI_ATTR VkResult VKAPI_CALL setPrivateDataEXT (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data)
2670 {
2671         DE_UNREF(device);
2672         DE_UNREF(objectType);
2673         DE_UNREF(objectHandle);
2674         DE_UNREF(privateDataSlot);
2675         DE_UNREF(data);
2676         return VK_SUCCESS;
2677 }
2678
2679 VKAPI_ATTR void VKAPI_CALL getPrivateDataEXT (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData)
2680 {
2681         DE_UNREF(device);
2682         DE_UNREF(objectType);
2683         DE_UNREF(objectHandle);
2684         DE_UNREF(privateDataSlot);
2685         DE_UNREF(pData);
2686 }
2687
2688 VKAPI_ATTR void VKAPI_CALL cmdSetFragmentShadingRateEnumNV (VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
2689 {
2690         DE_UNREF(commandBuffer);
2691         DE_UNREF(shadingRate);
2692         DE_UNREF(combinerOps);
2693 }
2694
2695 VKAPI_ATTR VkResult VKAPI_CALL acquireWinrtDisplayNV (VkPhysicalDevice physicalDevice, VkDisplayKHR display)
2696 {
2697         DE_UNREF(physicalDevice);
2698         DE_UNREF(display);
2699         return VK_SUCCESS;
2700 }
2701
2702 VKAPI_ATTR VkResult VKAPI_CALL getWinrtDisplayNV (VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay)
2703 {
2704         DE_UNREF(physicalDevice);
2705         DE_UNREF(deviceRelativeId);
2706         DE_UNREF(pDisplay);
2707         return VK_SUCCESS;
2708 }
2709
2710 VKAPI_ATTR void VKAPI_CALL cmdSetVertexInputEXT (VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions)
2711 {
2712         DE_UNREF(commandBuffer);
2713         DE_UNREF(vertexBindingDescriptionCount);
2714         DE_UNREF(pVertexBindingDescriptions);
2715         DE_UNREF(vertexAttributeDescriptionCount);
2716         DE_UNREF(pVertexAttributeDescriptions);
2717 }
2718
2719 VKAPI_ATTR VkResult VKAPI_CALL getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI (VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize)
2720 {
2721         DE_UNREF(device);
2722         DE_UNREF(renderpass);
2723         DE_UNREF(pMaxWorkgroupSize);
2724         return VK_SUCCESS;
2725 }
2726
2727 VKAPI_ATTR void VKAPI_CALL cmdSubpassShadingHUAWEI (VkCommandBuffer commandBuffer)
2728 {
2729         DE_UNREF(commandBuffer);
2730 }
2731
2732 VKAPI_ATTR void VKAPI_CALL cmdBindInvocationMaskHUAWEI (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
2733 {
2734         DE_UNREF(commandBuffer);
2735         DE_UNREF(imageView);
2736         DE_UNREF(imageLayout);
2737 }
2738
2739 VKAPI_ATTR VkResult VKAPI_CALL getMemoryRemoteAddressNV (VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress)
2740 {
2741         DE_UNREF(device);
2742         DE_UNREF(pMemoryGetRemoteAddressInfo);
2743         DE_UNREF(pAddress);
2744         return VK_SUCCESS;
2745 }
2746
2747 VKAPI_ATTR void VKAPI_CALL cmdSetPatchControlPointsEXT (VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
2748 {
2749         DE_UNREF(commandBuffer);
2750         DE_UNREF(patchControlPoints);
2751 }
2752
2753 VKAPI_ATTR void VKAPI_CALL cmdSetRasterizerDiscardEnableEXT (VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
2754 {
2755         DE_UNREF(commandBuffer);
2756         DE_UNREF(rasterizerDiscardEnable);
2757 }
2758
2759 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBiasEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
2760 {
2761         DE_UNREF(commandBuffer);
2762         DE_UNREF(depthBiasEnable);
2763 }
2764
2765 VKAPI_ATTR void VKAPI_CALL cmdSetLogicOpEXT (VkCommandBuffer commandBuffer, VkLogicOp logicOp)
2766 {
2767         DE_UNREF(commandBuffer);
2768         DE_UNREF(logicOp);
2769 }
2770
2771 VKAPI_ATTR void VKAPI_CALL cmdSetPrimitiveRestartEnableEXT (VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
2772 {
2773         DE_UNREF(commandBuffer);
2774         DE_UNREF(primitiveRestartEnable);
2775 }
2776
2777 VKAPI_ATTR void VKAPI_CALL cmdSetColorWriteEnableEXT (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables)
2778 {
2779         DE_UNREF(commandBuffer);
2780         DE_UNREF(attachmentCount);
2781         DE_UNREF(pColorWriteEnables);
2782 }
2783
2784 VKAPI_ATTR void VKAPI_CALL cmdDrawMultiEXT (VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
2785 {
2786         DE_UNREF(commandBuffer);
2787         DE_UNREF(drawCount);
2788         DE_UNREF(pVertexInfo);
2789         DE_UNREF(instanceCount);
2790         DE_UNREF(firstInstance);
2791         DE_UNREF(stride);
2792 }
2793
2794 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)
2795 {
2796         DE_UNREF(commandBuffer);
2797         DE_UNREF(drawCount);
2798         DE_UNREF(pIndexInfo);
2799         DE_UNREF(instanceCount);
2800         DE_UNREF(firstInstance);
2801         DE_UNREF(stride);
2802         DE_UNREF(pVertexOffset);
2803 }
2804
2805 VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructuresKHR (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
2806 {
2807         DE_UNREF(commandBuffer);
2808         DE_UNREF(infoCount);
2809         DE_UNREF(pInfos);
2810         DE_UNREF(ppBuildRangeInfos);
2811 }
2812
2813 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)
2814 {
2815         DE_UNREF(commandBuffer);
2816         DE_UNREF(infoCount);
2817         DE_UNREF(pInfos);
2818         DE_UNREF(pIndirectDeviceAddresses);
2819         DE_UNREF(pIndirectStrides);
2820         DE_UNREF(ppMaxPrimitiveCounts);
2821 }
2822
2823 VKAPI_ATTR VkResult VKAPI_CALL buildAccelerationStructuresKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
2824 {
2825         DE_UNREF(device);
2826         DE_UNREF(deferredOperation);
2827         DE_UNREF(infoCount);
2828         DE_UNREF(pInfos);
2829         DE_UNREF(ppBuildRangeInfos);
2830         return VK_SUCCESS;
2831 }
2832
2833 VKAPI_ATTR VkResult VKAPI_CALL copyAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* 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 copyAccelerationStructureToMemoryKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
2842 {
2843         DE_UNREF(device);
2844         DE_UNREF(deferredOperation);
2845         DE_UNREF(pInfo);
2846         return VK_SUCCESS;
2847 }
2848
2849 VKAPI_ATTR VkResult VKAPI_CALL copyMemoryToAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
2850 {
2851         DE_UNREF(device);
2852         DE_UNREF(deferredOperation);
2853         DE_UNREF(pInfo);
2854         return VK_SUCCESS;
2855 }
2856
2857 VKAPI_ATTR VkResult VKAPI_CALL writeAccelerationStructuresPropertiesKHR (VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride)
2858 {
2859         DE_UNREF(device);
2860         DE_UNREF(accelerationStructureCount);
2861         DE_UNREF(pAccelerationStructures);
2862         DE_UNREF(queryType);
2863         DE_UNREF(dataSize);
2864         DE_UNREF(pData);
2865         DE_UNREF(stride);
2866         return VK_SUCCESS;
2867 }
2868
2869 VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo)
2870 {
2871         DE_UNREF(commandBuffer);
2872         DE_UNREF(pInfo);
2873 }
2874
2875 VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureToMemoryKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
2876 {
2877         DE_UNREF(commandBuffer);
2878         DE_UNREF(pInfo);
2879 }
2880
2881 VKAPI_ATTR void VKAPI_CALL cmdCopyMemoryToAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
2882 {
2883         DE_UNREF(commandBuffer);
2884         DE_UNREF(pInfo);
2885 }
2886
2887 VKAPI_ATTR VkDeviceAddress VKAPI_CALL getAccelerationStructureDeviceAddressKHR (VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
2888 {
2889         DE_UNREF(device);
2890         DE_UNREF(pInfo);
2891         return VK_SUCCESS;
2892 }
2893
2894 VKAPI_ATTR void VKAPI_CALL cmdWriteAccelerationStructuresPropertiesKHR (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2895 {
2896         DE_UNREF(commandBuffer);
2897         DE_UNREF(accelerationStructureCount);
2898         DE_UNREF(pAccelerationStructures);
2899         DE_UNREF(queryType);
2900         DE_UNREF(queryPool);
2901         DE_UNREF(firstQuery);
2902 }
2903
2904 VKAPI_ATTR void VKAPI_CALL getDeviceAccelerationStructureCompatibilityKHR (VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility)
2905 {
2906         DE_UNREF(device);
2907         DE_UNREF(pVersionInfo);
2908         DE_UNREF(pCompatibility);
2909 }
2910
2911 VKAPI_ATTR void VKAPI_CALL getAccelerationStructureBuildSizesKHR (VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo)
2912 {
2913         DE_UNREF(device);
2914         DE_UNREF(buildType);
2915         DE_UNREF(pBuildInfo);
2916         DE_UNREF(pMaxPrimitiveCounts);
2917         DE_UNREF(pSizeInfo);
2918 }
2919
2920 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)
2921 {
2922         DE_UNREF(commandBuffer);
2923         DE_UNREF(pRaygenShaderBindingTable);
2924         DE_UNREF(pMissShaderBindingTable);
2925         DE_UNREF(pHitShaderBindingTable);
2926         DE_UNREF(pCallableShaderBindingTable);
2927         DE_UNREF(width);
2928         DE_UNREF(height);
2929         DE_UNREF(depth);
2930 }
2931
2932 VKAPI_ATTR VkResult VKAPI_CALL getRayTracingCaptureReplayShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
2933 {
2934         DE_UNREF(device);
2935         DE_UNREF(pipeline);
2936         DE_UNREF(firstGroup);
2937         DE_UNREF(groupCount);
2938         DE_UNREF(dataSize);
2939         DE_UNREF(pData);
2940         return VK_SUCCESS;
2941 }
2942
2943 VKAPI_ATTR void VKAPI_CALL cmdTraceRaysIndirectKHR (VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
2944 {
2945         DE_UNREF(commandBuffer);
2946         DE_UNREF(pRaygenShaderBindingTable);
2947         DE_UNREF(pMissShaderBindingTable);
2948         DE_UNREF(pHitShaderBindingTable);
2949         DE_UNREF(pCallableShaderBindingTable);
2950         DE_UNREF(indirectDeviceAddress);
2951 }
2952
2953 VKAPI_ATTR VkDeviceSize VKAPI_CALL getRayTracingShaderGroupStackSizeKHR (VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
2954 {
2955         DE_UNREF(device);
2956         DE_UNREF(pipeline);
2957         DE_UNREF(group);
2958         DE_UNREF(groupShader);
2959         return VK_SUCCESS;
2960 }
2961
2962 VKAPI_ATTR void VKAPI_CALL cmdSetRayTracingPipelineStackSizeKHR (VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
2963 {
2964         DE_UNREF(commandBuffer);
2965         DE_UNREF(pipelineStackSize);
2966 }
2967
2968 VKAPI_ATTR VkResult VKAPI_CALL getAndroidHardwareBufferPropertiesANDROID (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties)
2969 {
2970         DE_UNREF(device);
2971         DE_UNREF(buffer);
2972         DE_UNREF(pProperties);
2973         return VK_SUCCESS;
2974 }
2975
2976 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoCapabilitiesKHR (VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities)
2977 {
2978         DE_UNREF(physicalDevice);
2979         DE_UNREF(pVideoProfile);
2980         DE_UNREF(pCapabilities);
2981         return VK_SUCCESS;
2982 }
2983
2984 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoFormatPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties)
2985 {
2986         DE_UNREF(physicalDevice);
2987         DE_UNREF(pVideoFormatInfo);
2988         DE_UNREF(pVideoFormatPropertyCount);
2989         DE_UNREF(pVideoFormatProperties);
2990         return VK_SUCCESS;
2991 }
2992
2993 VKAPI_ATTR VkResult VKAPI_CALL getVideoSessionMemoryRequirementsKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements)
2994 {
2995         DE_UNREF(device);
2996         DE_UNREF(videoSession);
2997         DE_UNREF(pVideoSessionMemoryRequirementsCount);
2998         DE_UNREF(pVideoSessionMemoryRequirements);
2999         return VK_SUCCESS;
3000 }
3001
3002 VKAPI_ATTR VkResult VKAPI_CALL bindVideoSessionMemoryKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories)
3003 {
3004         DE_UNREF(device);
3005         DE_UNREF(videoSession);
3006         DE_UNREF(videoSessionBindMemoryCount);
3007         DE_UNREF(pVideoSessionBindMemories);
3008         return VK_SUCCESS;
3009 }
3010
3011 VKAPI_ATTR VkResult VKAPI_CALL updateVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo)
3012 {
3013         DE_UNREF(device);
3014         DE_UNREF(videoSessionParameters);
3015         DE_UNREF(pUpdateInfo);
3016         return VK_SUCCESS;
3017 }
3018
3019 VKAPI_ATTR void VKAPI_CALL cmdBeginVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo)
3020 {
3021         DE_UNREF(commandBuffer);
3022         DE_UNREF(pBeginInfo);
3023 }
3024
3025 VKAPI_ATTR void VKAPI_CALL cmdEndVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo)
3026 {
3027         DE_UNREF(commandBuffer);
3028         DE_UNREF(pEndCodingInfo);
3029 }
3030
3031 VKAPI_ATTR void VKAPI_CALL cmdControlVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo)
3032 {
3033         DE_UNREF(commandBuffer);
3034         DE_UNREF(pCodingControlInfo);
3035 }
3036
3037 VKAPI_ATTR void VKAPI_CALL cmdDecodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo)
3038 {
3039         DE_UNREF(commandBuffer);
3040         DE_UNREF(pFrameInfo);
3041 }
3042
3043 VKAPI_ATTR void VKAPI_CALL cmdEncodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo)
3044 {
3045         DE_UNREF(commandBuffer);
3046         DE_UNREF(pEncodeInfo);
3047 }
3048
3049 VKAPI_ATTR VkResult VKAPI_CALL getMemoryZirconHandleFUCHSIA (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle)
3050 {
3051         DE_UNREF(device);
3052         DE_UNREF(pGetZirconHandleInfo);
3053         DE_UNREF(pZirconHandle);
3054         return VK_SUCCESS;
3055 }
3056
3057 VKAPI_ATTR VkResult VKAPI_CALL getMemoryZirconHandlePropertiesFUCHSIA (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties)
3058 {
3059         DE_UNREF(device);
3060         DE_UNREF(handleType);
3061         DE_UNREF(zirconHandle);
3062         DE_UNREF(pMemoryZirconHandleProperties);
3063         return VK_SUCCESS;
3064 }
3065
3066 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
3067 {
3068         DE_UNREF(device);
3069         DE_UNREF(pImportSemaphoreZirconHandleInfo);
3070         return VK_SUCCESS;
3071 }
3072
3073 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle)
3074 {
3075         DE_UNREF(device);
3076         DE_UNREF(pGetZirconHandleInfo);
3077         DE_UNREF(pZirconHandle);
3078         return VK_SUCCESS;
3079 }
3080
3081 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWaylandPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::WaylandDisplayPtr display)
3082 {
3083         DE_UNREF(physicalDevice);
3084         DE_UNREF(queueFamilyIndex);
3085         DE_UNREF(display);
3086         return VK_SUCCESS;
3087 }
3088
3089 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
3090 {
3091         DE_UNREF(physicalDevice);
3092         DE_UNREF(queueFamilyIndex);
3093         return VK_SUCCESS;
3094 }
3095
3096 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
3097 {
3098         DE_UNREF(device);
3099         DE_UNREF(pGetWin32HandleInfo);
3100         DE_UNREF(pHandle);
3101         return VK_SUCCESS;
3102 }
3103
3104 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
3105 {
3106         DE_UNREF(device);
3107         DE_UNREF(handleType);
3108         DE_UNREF(handle);
3109         DE_UNREF(pMemoryWin32HandleProperties);
3110         return VK_SUCCESS;
3111 }
3112
3113 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreWin32HandleKHR (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
3114 {
3115         DE_UNREF(device);
3116         DE_UNREF(pImportSemaphoreWin32HandleInfo);
3117         return VK_SUCCESS;
3118 }
3119
3120 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreWin32HandleKHR (VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
3121 {
3122         DE_UNREF(device);
3123         DE_UNREF(pGetWin32HandleInfo);
3124         DE_UNREF(pHandle);
3125         return VK_SUCCESS;
3126 }
3127
3128 VKAPI_ATTR VkResult VKAPI_CALL importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
3129 {
3130         DE_UNREF(device);
3131         DE_UNREF(pImportFenceWin32HandleInfo);
3132         return VK_SUCCESS;
3133 }
3134
3135 VKAPI_ATTR VkResult VKAPI_CALL getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
3136 {
3137         DE_UNREF(device);
3138         DE_UNREF(pGetWin32HandleInfo);
3139         DE_UNREF(pHandle);
3140         return VK_SUCCESS;
3141 }
3142
3143 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle)
3144 {
3145         DE_UNREF(device);
3146         DE_UNREF(memory);
3147         DE_UNREF(handleType);
3148         DE_UNREF(pHandle);
3149         return VK_SUCCESS;
3150 }
3151
3152 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModes2EXT (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
3153 {
3154         DE_UNREF(physicalDevice);
3155         DE_UNREF(pSurfaceInfo);
3156         DE_UNREF(pPresentModeCount);
3157         DE_UNREF(pPresentModes);
3158         return VK_SUCCESS;
3159 }
3160
3161 VKAPI_ATTR VkResult VKAPI_CALL acquireFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain)
3162 {
3163         DE_UNREF(device);
3164         DE_UNREF(swapchain);
3165         return VK_SUCCESS;
3166 }
3167
3168 VKAPI_ATTR VkResult VKAPI_CALL releaseFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain)
3169 {
3170         DE_UNREF(device);
3171         DE_UNREF(swapchain);
3172         return VK_SUCCESS;
3173 }
3174
3175 VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupSurfacePresentModes2EXT (VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes)
3176 {
3177         DE_UNREF(device);
3178         DE_UNREF(pSurfaceInfo);
3179         DE_UNREF(pModes);
3180         return VK_SUCCESS;
3181 }
3182
3183 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXcbPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XcbConnectionPtr connection, pt::XcbVisualid visual_id)
3184 {
3185         DE_UNREF(physicalDevice);
3186         DE_UNREF(queueFamilyIndex);
3187         DE_UNREF(connection);
3188         DE_UNREF(visual_id);
3189         return VK_SUCCESS;
3190 }
3191
3192 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXlibPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XlibDisplayPtr dpy, pt::XlibVisualID visualID)
3193 {
3194         DE_UNREF(physicalDevice);
3195         DE_UNREF(queueFamilyIndex);
3196         DE_UNREF(dpy);
3197         DE_UNREF(visualID);
3198         return VK_SUCCESS;
3199 }
3200
3201 VKAPI_ATTR VkResult VKAPI_CALL acquireXlibDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, VkDisplayKHR display)
3202 {
3203         DE_UNREF(physicalDevice);
3204         DE_UNREF(dpy);
3205         DE_UNREF(display);
3206         return VK_SUCCESS;
3207 }
3208
3209 VKAPI_ATTR VkResult VKAPI_CALL getRandROutputDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, pt::RROutput rrOutput, VkDisplayKHR* pDisplay)
3210 {
3211         DE_UNREF(physicalDevice);
3212         DE_UNREF(dpy);
3213         DE_UNREF(rrOutput);
3214         DE_UNREF(pDisplay);
3215         return VK_SUCCESS;
3216 }
3217
3218 static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
3219 {
3220         VK_NULL_FUNC_ENTRY(vkCreateInstance,                                            createInstance),
3221         VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr,                                       getInstanceProcAddr),
3222         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceExtensionProperties,      enumerateInstanceExtensionProperties),
3223         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceLayerProperties,          enumerateInstanceLayerProperties),
3224         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceVersion,                          enumerateInstanceVersion),
3225 };
3226
3227 static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
3228 {
3229         VK_NULL_FUNC_ENTRY(vkDestroyInstance,                                                                                                   destroyInstance),
3230         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDevices,                                                                                  enumeratePhysicalDevices),
3231         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures,                                                                                 getPhysicalDeviceFeatures),
3232         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties,                                                                 getPhysicalDeviceFormatProperties),
3233         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties,                                                    getPhysicalDeviceImageFormatProperties),
3234         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties,                                                                               getPhysicalDeviceProperties),
3235         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties,                                                    getPhysicalDeviceQueueFamilyProperties),
3236         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties,                                                                 getPhysicalDeviceMemoryProperties),
3237         VK_NULL_FUNC_ENTRY(vkCreateDevice,                                                                                                              createDevice),
3238         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceExtensionProperties,                                                                enumerateDeviceExtensionProperties),
3239         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceLayerProperties,                                                                    enumerateDeviceLayerProperties),
3240         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties,                                              getPhysicalDeviceSparseImageFormatProperties),
3241         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceGroups,                                                                             enumeratePhysicalDeviceGroups),
3242         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures2,                                                                                getPhysicalDeviceFeatures2),
3243         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties2,                                                                              getPhysicalDeviceProperties2),
3244         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties2,                                                                getPhysicalDeviceFormatProperties2),
3245         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties2,                                                   getPhysicalDeviceImageFormatProperties2),
3246         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2,                                                   getPhysicalDeviceQueueFamilyProperties2),
3247         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2,                                                                getPhysicalDeviceMemoryProperties2),
3248         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2,                                             getPhysicalDeviceSparseImageFormatProperties2),
3249         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferProperties,                                                 getPhysicalDeviceExternalBufferProperties),
3250         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFenceProperties,                                                  getPhysicalDeviceExternalFenceProperties),
3251         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphoreProperties,                                              getPhysicalDeviceExternalSemaphoreProperties),
3252         VK_NULL_FUNC_ENTRY(vkDestroySurfaceKHR,                                                                                                 destroySurfaceKHR),
3253         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceSupportKHR,                                                                getPhysicalDeviceSurfaceSupportKHR),
3254         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilitiesKHR,                                                   getPhysicalDeviceSurfaceCapabilitiesKHR),
3255         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormatsKHR,                                                                getPhysicalDeviceSurfaceFormatsKHR),
3256         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModesKHR,                                                   getPhysicalDeviceSurfacePresentModesKHR),
3257         VK_NULL_FUNC_ENTRY(vkGetPhysicalDevicePresentRectanglesKHR,                                                             getPhysicalDevicePresentRectanglesKHR),
3258         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPropertiesKHR,                                                             getPhysicalDeviceDisplayPropertiesKHR),
3259         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlanePropertiesKHR,                                                getPhysicalDeviceDisplayPlanePropertiesKHR),
3260         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneSupportedDisplaysKHR,                                                               getDisplayPlaneSupportedDisplaysKHR),
3261         VK_NULL_FUNC_ENTRY(vkGetDisplayModePropertiesKHR,                                                                               getDisplayModePropertiesKHR),
3262         VK_NULL_FUNC_ENTRY(vkCreateDisplayModeKHR,                                                                                              createDisplayModeKHR),
3263         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilitiesKHR,                                                                    getDisplayPlaneCapabilitiesKHR),
3264         VK_NULL_FUNC_ENTRY(vkCreateDisplayPlaneSurfaceKHR,                                                                              createDisplayPlaneSurfaceKHR),
3265         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures2KHR,                                                                             getPhysicalDeviceFeatures2),
3266         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties2KHR,                                                                   getPhysicalDeviceProperties2),
3267         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties2KHR,                                                             getPhysicalDeviceFormatProperties2),
3268         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties2KHR,                                                getPhysicalDeviceImageFormatProperties2),
3269         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2KHR,                                                getPhysicalDeviceQueueFamilyProperties2),
3270         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2KHR,                                                             getPhysicalDeviceMemoryProperties2),
3271         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2KHR,                                  getPhysicalDeviceSparseImageFormatProperties2),
3272         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceGroupsKHR,                                                                  enumeratePhysicalDeviceGroups),
3273         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferPropertiesKHR,                                              getPhysicalDeviceExternalBufferProperties),
3274         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,                                   getPhysicalDeviceExternalSemaphoreProperties),
3275         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFencePropertiesKHR,                                               getPhysicalDeviceExternalFenceProperties),
3276         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,             enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR),
3277         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,                             getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR),
3278         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2KHR,                                                  getPhysicalDeviceSurfaceCapabilities2KHR),
3279         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormats2KHR,                                                               getPhysicalDeviceSurfaceFormats2KHR),
3280         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayProperties2KHR,                                                    getPhysicalDeviceDisplayProperties2KHR),
3281         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlaneProperties2KHR,                                               getPhysicalDeviceDisplayPlaneProperties2KHR),
3282         VK_NULL_FUNC_ENTRY(vkGetDisplayModeProperties2KHR,                                                                              getDisplayModeProperties2KHR),
3283         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilities2KHR,                                                                   getDisplayPlaneCapabilities2KHR),
3284         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFragmentShadingRatesKHR,                                                  getPhysicalDeviceFragmentShadingRatesKHR),
3285         VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT,                                                                              createDebugReportCallbackEXT),
3286         VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT,                                                                             destroyDebugReportCallbackEXT),
3287         VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT,                                                                                             debugReportMessageEXT),
3288         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalImageFormatPropertiesNV,                                  getPhysicalDeviceExternalImageFormatPropertiesNV),
3289         VK_NULL_FUNC_ENTRY(vkReleaseDisplayEXT,                                                                                                 releaseDisplayEXT),
3290         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2EXT,                                                  getPhysicalDeviceSurfaceCapabilities2EXT),
3291         VK_NULL_FUNC_ENTRY(vkCreateDebugUtilsMessengerEXT,                                                                              createDebugUtilsMessengerEXT),
3292         VK_NULL_FUNC_ENTRY(vkDestroyDebugUtilsMessengerEXT,                                                                             destroyDebugUtilsMessengerEXT),
3293         VK_NULL_FUNC_ENTRY(vkSubmitDebugUtilsMessageEXT,                                                                                submitDebugUtilsMessageEXT),
3294         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMultisamplePropertiesEXT,                                                 getPhysicalDeviceMultisamplePropertiesEXT),
3295         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,                                              getPhysicalDeviceCalibrateableTimeDomainsEXT),
3296         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceToolPropertiesEXT,                                                                getPhysicalDeviceToolPropertiesEXT),
3297         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,                                    getPhysicalDeviceCooperativeMatrixPropertiesNV),
3298         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,   getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV),
3299         VK_NULL_FUNC_ENTRY(vkCreateHeadlessSurfaceEXT,                                                                                  createHeadlessSurfaceEXT),
3300         VK_NULL_FUNC_ENTRY(vkAcquireDrmDisplayEXT,                                                                                              acquireDrmDisplayEXT),
3301         VK_NULL_FUNC_ENTRY(vkGetDrmDisplayEXT,                                                                                                  getDrmDisplayEXT),
3302         VK_NULL_FUNC_ENTRY(vkAcquireWinrtDisplayNV,                                                                                             acquireWinrtDisplayNV),
3303         VK_NULL_FUNC_ENTRY(vkGetWinrtDisplayNV,                                                                                                 getWinrtDisplayNV),
3304         VK_NULL_FUNC_ENTRY(vkCreateAndroidSurfaceKHR,                                                                                   createAndroidSurfaceKHR),
3305         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoCapabilitiesKHR,                                                             getPhysicalDeviceVideoCapabilitiesKHR),
3306         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoFormatPropertiesKHR,                                                 getPhysicalDeviceVideoFormatPropertiesKHR),
3307         VK_NULL_FUNC_ENTRY(vkCreateImagePipeSurfaceFUCHSIA,                                                                             createImagePipeSurfaceFUCHSIA),
3308         VK_NULL_FUNC_ENTRY(vkCreateStreamDescriptorSurfaceGGP,                                                                  createStreamDescriptorSurfaceGGP),
3309         VK_NULL_FUNC_ENTRY(vkCreateIOSSurfaceMVK,                                                                                               createIOSSurfaceMVK),
3310         VK_NULL_FUNC_ENTRY(vkCreateMacOSSurfaceMVK,                                                                                             createMacOSSurfaceMVK),
3311         VK_NULL_FUNC_ENTRY(vkCreateMetalSurfaceEXT,                                                                                             createMetalSurfaceEXT),
3312         VK_NULL_FUNC_ENTRY(vkCreateViSurfaceNN,                                                                                                 createViSurfaceNN),
3313         VK_NULL_FUNC_ENTRY(vkCreateWaylandSurfaceKHR,                                                                                   createWaylandSurfaceKHR),
3314         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWaylandPresentationSupportKHR,                                    getPhysicalDeviceWaylandPresentationSupportKHR),
3315         VK_NULL_FUNC_ENTRY(vkCreateWin32SurfaceKHR,                                                                                             createWin32SurfaceKHR),
3316         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWin32PresentationSupportKHR,                                              getPhysicalDeviceWin32PresentationSupportKHR),
3317         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModes2EXT,                                                  getPhysicalDeviceSurfacePresentModes2EXT),
3318         VK_NULL_FUNC_ENTRY(vkCreateXcbSurfaceKHR,                                                                                               createXcbSurfaceKHR),
3319         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXcbPresentationSupportKHR,                                                getPhysicalDeviceXcbPresentationSupportKHR),
3320         VK_NULL_FUNC_ENTRY(vkCreateXlibSurfaceKHR,                                                                                              createXlibSurfaceKHR),
3321         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXlibPresentationSupportKHR,                                               getPhysicalDeviceXlibPresentationSupportKHR),
3322         VK_NULL_FUNC_ENTRY(vkAcquireXlibDisplayEXT,                                                                                             acquireXlibDisplayEXT),
3323         VK_NULL_FUNC_ENTRY(vkGetRandROutputDisplayEXT,                                                                                  getRandROutputDisplayEXT),
3324 };
3325
3326 static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
3327 {
3328         VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr,                                                                 getDeviceProcAddr),
3329         VK_NULL_FUNC_ENTRY(vkDestroyDevice,                                                                             destroyDevice),
3330         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue,                                                                    getDeviceQueue),
3331         VK_NULL_FUNC_ENTRY(vkQueueSubmit,                                                                               queueSubmit),
3332         VK_NULL_FUNC_ENTRY(vkQueueWaitIdle,                                                                             queueWaitIdle),
3333         VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle,                                                                    deviceWaitIdle),
3334         VK_NULL_FUNC_ENTRY(vkAllocateMemory,                                                                    allocateMemory),
3335         VK_NULL_FUNC_ENTRY(vkFreeMemory,                                                                                freeMemory),
3336         VK_NULL_FUNC_ENTRY(vkMapMemory,                                                                                 mapMemory),
3337         VK_NULL_FUNC_ENTRY(vkUnmapMemory,                                                                               unmapMemory),
3338         VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges,                                                   flushMappedMemoryRanges),
3339         VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges,                                              invalidateMappedMemoryRanges),
3340         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment,                                                 getDeviceMemoryCommitment),
3341         VK_NULL_FUNC_ENTRY(vkBindBufferMemory,                                                                  bindBufferMemory),
3342         VK_NULL_FUNC_ENTRY(vkBindImageMemory,                                                                   bindImageMemory),
3343         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements,                                               getBufferMemoryRequirements),
3344         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements,                                                getImageMemoryRequirements),
3345         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements,                                  getImageSparseMemoryRequirements),
3346         VK_NULL_FUNC_ENTRY(vkQueueBindSparse,                                                                   queueBindSparse),
3347         VK_NULL_FUNC_ENTRY(vkCreateFence,                                                                               createFence),
3348         VK_NULL_FUNC_ENTRY(vkDestroyFence,                                                                              destroyFence),
3349         VK_NULL_FUNC_ENTRY(vkResetFences,                                                                               resetFences),
3350         VK_NULL_FUNC_ENTRY(vkGetFenceStatus,                                                                    getFenceStatus),
3351         VK_NULL_FUNC_ENTRY(vkWaitForFences,                                                                             waitForFences),
3352         VK_NULL_FUNC_ENTRY(vkCreateSemaphore,                                                                   createSemaphore),
3353         VK_NULL_FUNC_ENTRY(vkDestroySemaphore,                                                                  destroySemaphore),
3354         VK_NULL_FUNC_ENTRY(vkCreateEvent,                                                                               createEvent),
3355         VK_NULL_FUNC_ENTRY(vkDestroyEvent,                                                                              destroyEvent),
3356         VK_NULL_FUNC_ENTRY(vkGetEventStatus,                                                                    getEventStatus),
3357         VK_NULL_FUNC_ENTRY(vkSetEvent,                                                                                  setEvent),
3358         VK_NULL_FUNC_ENTRY(vkResetEvent,                                                                                resetEvent),
3359         VK_NULL_FUNC_ENTRY(vkCreateQueryPool,                                                                   createQueryPool),
3360         VK_NULL_FUNC_ENTRY(vkDestroyQueryPool,                                                                  destroyQueryPool),
3361         VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults,                                                               getQueryPoolResults),
3362         VK_NULL_FUNC_ENTRY(vkCreateBuffer,                                                                              createBuffer),
3363         VK_NULL_FUNC_ENTRY(vkDestroyBuffer,                                                                             destroyBuffer),
3364         VK_NULL_FUNC_ENTRY(vkCreateBufferView,                                                                  createBufferView),
3365         VK_NULL_FUNC_ENTRY(vkDestroyBufferView,                                                                 destroyBufferView),
3366         VK_NULL_FUNC_ENTRY(vkCreateImage,                                                                               createImage),
3367         VK_NULL_FUNC_ENTRY(vkDestroyImage,                                                                              destroyImage),
3368         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout,                                                 getImageSubresourceLayout),
3369         VK_NULL_FUNC_ENTRY(vkCreateImageView,                                                                   createImageView),
3370         VK_NULL_FUNC_ENTRY(vkDestroyImageView,                                                                  destroyImageView),
3371         VK_NULL_FUNC_ENTRY(vkCreateShaderModule,                                                                createShaderModule),
3372         VK_NULL_FUNC_ENTRY(vkDestroyShaderModule,                                                               destroyShaderModule),
3373         VK_NULL_FUNC_ENTRY(vkCreatePipelineCache,                                                               createPipelineCache),
3374         VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache,                                                              destroyPipelineCache),
3375         VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData,                                                              getPipelineCacheData),
3376         VK_NULL_FUNC_ENTRY(vkMergePipelineCaches,                                                               mergePipelineCaches),
3377         VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines,                                                   createGraphicsPipelines),
3378         VK_NULL_FUNC_ENTRY(vkCreateComputePipelines,                                                    createComputePipelines),
3379         VK_NULL_FUNC_ENTRY(vkDestroyPipeline,                                                                   destroyPipeline),
3380         VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout,                                                              createPipelineLayout),
3381         VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout,                                                             destroyPipelineLayout),
3382         VK_NULL_FUNC_ENTRY(vkCreateSampler,                                                                             createSampler),
3383         VK_NULL_FUNC_ENTRY(vkDestroySampler,                                                                    destroySampler),
3384         VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout,                                                 createDescriptorSetLayout),
3385         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout,                                                destroyDescriptorSetLayout),
3386         VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool,                                                              createDescriptorPool),
3387         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool,                                                             destroyDescriptorPool),
3388         VK_NULL_FUNC_ENTRY(vkResetDescriptorPool,                                                               resetDescriptorPool),
3389         VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets,                                                    allocateDescriptorSets),
3390         VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets,                                                                freeDescriptorSets),
3391         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets,                                                              updateDescriptorSets),
3392         VK_NULL_FUNC_ENTRY(vkCreateFramebuffer,                                                                 createFramebuffer),
3393         VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer,                                                                destroyFramebuffer),
3394         VK_NULL_FUNC_ENTRY(vkCreateRenderPass,                                                                  createRenderPass),
3395         VK_NULL_FUNC_ENTRY(vkDestroyRenderPass,                                                                 destroyRenderPass),
3396         VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity,                                                  getRenderAreaGranularity),
3397         VK_NULL_FUNC_ENTRY(vkCreateCommandPool,                                                                 createCommandPool),
3398         VK_NULL_FUNC_ENTRY(vkDestroyCommandPool,                                                                destroyCommandPool),
3399         VK_NULL_FUNC_ENTRY(vkResetCommandPool,                                                                  resetCommandPool),
3400         VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers,                                                    allocateCommandBuffers),
3401         VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers,                                                                freeCommandBuffers),
3402         VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer,                                                                beginCommandBuffer),
3403         VK_NULL_FUNC_ENTRY(vkEndCommandBuffer,                                                                  endCommandBuffer),
3404         VK_NULL_FUNC_ENTRY(vkResetCommandBuffer,                                                                resetCommandBuffer),
3405         VK_NULL_FUNC_ENTRY(vkCmdBindPipeline,                                                                   cmdBindPipeline),
3406         VK_NULL_FUNC_ENTRY(vkCmdSetViewport,                                                                    cmdSetViewport),
3407         VK_NULL_FUNC_ENTRY(vkCmdSetScissor,                                                                             cmdSetScissor),
3408         VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth,                                                                   cmdSetLineWidth),
3409         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias,                                                                   cmdSetDepthBias),
3410         VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants,                                                              cmdSetBlendConstants),
3411         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds,                                                                 cmdSetDepthBounds),
3412         VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask,                                                  cmdSetStencilCompareMask),
3413         VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask,                                                    cmdSetStencilWriteMask),
3414         VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference,                                                    cmdSetStencilReference),
3415         VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets,                                                             cmdBindDescriptorSets),
3416         VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer,                                                                cmdBindIndexBuffer),
3417         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers,                                                              cmdBindVertexBuffers),
3418         VK_NULL_FUNC_ENTRY(vkCmdDraw,                                                                                   cmdDraw),
3419         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed,                                                                    cmdDrawIndexed),
3420         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect,                                                                   cmdDrawIndirect),
3421         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect,                                                    cmdDrawIndexedIndirect),
3422         VK_NULL_FUNC_ENTRY(vkCmdDispatch,                                                                               cmdDispatch),
3423         VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect,                                                               cmdDispatchIndirect),
3424         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer,                                                                             cmdCopyBuffer),
3425         VK_NULL_FUNC_ENTRY(vkCmdCopyImage,                                                                              cmdCopyImage),
3426         VK_NULL_FUNC_ENTRY(vkCmdBlitImage,                                                                              cmdBlitImage),
3427         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage,                                                              cmdCopyBufferToImage),
3428         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer,                                                              cmdCopyImageToBuffer),
3429         VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer,                                                                   cmdUpdateBuffer),
3430         VK_NULL_FUNC_ENTRY(vkCmdFillBuffer,                                                                             cmdFillBuffer),
3431         VK_NULL_FUNC_ENTRY(vkCmdClearColorImage,                                                                cmdClearColorImage),
3432         VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage,                                                 cmdClearDepthStencilImage),
3433         VK_NULL_FUNC_ENTRY(vkCmdClearAttachments,                                                               cmdClearAttachments),
3434         VK_NULL_FUNC_ENTRY(vkCmdResolveImage,                                                                   cmdResolveImage),
3435         VK_NULL_FUNC_ENTRY(vkCmdSetEvent,                                                                               cmdSetEvent),
3436         VK_NULL_FUNC_ENTRY(vkCmdResetEvent,                                                                             cmdResetEvent),
3437         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents,                                                                             cmdWaitEvents),
3438         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier,                                                                cmdPipelineBarrier),
3439         VK_NULL_FUNC_ENTRY(vkCmdBeginQuery,                                                                             cmdBeginQuery),
3440         VK_NULL_FUNC_ENTRY(vkCmdEndQuery,                                                                               cmdEndQuery),
3441         VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool,                                                                 cmdResetQueryPool),
3442         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp,                                                                 cmdWriteTimestamp),
3443         VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults,                                                   cmdCopyQueryPoolResults),
3444         VK_NULL_FUNC_ENTRY(vkCmdPushConstants,                                                                  cmdPushConstants),
3445         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass,                                                                cmdBeginRenderPass),
3446         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass,                                                                    cmdNextSubpass),
3447         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass,                                                                  cmdEndRenderPass),
3448         VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands,                                                                cmdExecuteCommands),
3449         VK_NULL_FUNC_ENTRY(vkBindBufferMemory2,                                                                 bindBufferMemory2),
3450         VK_NULL_FUNC_ENTRY(vkBindImageMemory2,                                                                  bindImageMemory2),
3451         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeatures,                                  getDeviceGroupPeerMemoryFeatures),
3452         VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMask,                                                                  cmdSetDeviceMask),
3453         VK_NULL_FUNC_ENTRY(vkCmdDispatchBase,                                                                   cmdDispatchBase),
3454         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2,                                               getImageMemoryRequirements2),
3455         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2,                                              getBufferMemoryRequirements2),
3456         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2,                                 getImageSparseMemoryRequirements2),
3457         VK_NULL_FUNC_ENTRY(vkTrimCommandPool,                                                                   trimCommandPool),
3458         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue2,                                                                   getDeviceQueue2),
3459         VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversion,                                              createSamplerYcbcrConversion),
3460         VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversion,                                             destroySamplerYcbcrConversion),
3461         VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplate,                                    createDescriptorUpdateTemplate),
3462         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplate,                                   destroyDescriptorUpdateTemplate),
3463         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplate,                                   updateDescriptorSetWithTemplate),
3464         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupport,                                             getDescriptorSetLayoutSupport),
3465         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCount,                                                              cmdDrawIndirectCount),
3466         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCount,                                               cmdDrawIndexedIndirectCount),
3467         VK_NULL_FUNC_ENTRY(vkCreateRenderPass2,                                                                 createRenderPass2),
3468         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass2,                                                               cmdBeginRenderPass2),
3469         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass2,                                                                   cmdNextSubpass2),
3470         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass2,                                                                 cmdEndRenderPass2),
3471         VK_NULL_FUNC_ENTRY(vkResetQueryPool,                                                                    resetQueryPool),
3472         VK_NULL_FUNC_ENTRY(vkGetSemaphoreCounterValue,                                                  getSemaphoreCounterValue),
3473         VK_NULL_FUNC_ENTRY(vkWaitSemaphores,                                                                    waitSemaphores),
3474         VK_NULL_FUNC_ENTRY(vkSignalSemaphore,                                                                   signalSemaphore),
3475         VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddress,                                                    getBufferDeviceAddress),
3476         VK_NULL_FUNC_ENTRY(vkGetBufferOpaqueCaptureAddress,                                             getBufferOpaqueCaptureAddress),
3477         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryOpaqueCaptureAddress,                               getDeviceMemoryOpaqueCaptureAddress),
3478         VK_NULL_FUNC_ENTRY(vkCreateSwapchainKHR,                                                                createSwapchainKHR),
3479         VK_NULL_FUNC_ENTRY(vkDestroySwapchainKHR,                                                               destroySwapchainKHR),
3480         VK_NULL_FUNC_ENTRY(vkGetSwapchainImagesKHR,                                                             getSwapchainImagesKHR),
3481         VK_NULL_FUNC_ENTRY(vkAcquireNextImageKHR,                                                               acquireNextImageKHR),
3482         VK_NULL_FUNC_ENTRY(vkQueuePresentKHR,                                                                   queuePresentKHR),
3483         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPresentCapabilitiesKHR,                              getDeviceGroupPresentCapabilitiesKHR),
3484         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModesKHR,                              getDeviceGroupSurfacePresentModesKHR),
3485         VK_NULL_FUNC_ENTRY(vkAcquireNextImage2KHR,                                                              acquireNextImage2KHR),
3486         VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR,                                                 createSharedSwapchainsKHR),
3487         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeaturesKHR,                               getDeviceGroupPeerMemoryFeatures),
3488         VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMaskKHR,                                                               cmdSetDeviceMask),
3489         VK_NULL_FUNC_ENTRY(vkCmdDispatchBaseKHR,                                                                cmdDispatchBase),
3490         VK_NULL_FUNC_ENTRY(vkTrimCommandPoolKHR,                                                                trimCommandPool),
3491         VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHR,                                                                    getMemoryFdKHR),
3492         VK_NULL_FUNC_ENTRY(vkGetMemoryFdPropertiesKHR,                                                  getMemoryFdPropertiesKHR),
3493         VK_NULL_FUNC_ENTRY(vkImportSemaphoreFdKHR,                                                              importSemaphoreFdKHR),
3494         VK_NULL_FUNC_ENTRY(vkGetSemaphoreFdKHR,                                                                 getSemaphoreFdKHR),
3495         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR,                                                   cmdPushDescriptorSetKHR),
3496         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR,                               cmdPushDescriptorSetWithTemplateKHR),
3497         VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplateKHR,                                 createDescriptorUpdateTemplate),
3498         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplateKHR,                                destroyDescriptorUpdateTemplate),
3499         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplateKHR,                                updateDescriptorSetWithTemplate),
3500         VK_NULL_FUNC_ENTRY(vkCreateRenderPass2KHR,                                                              createRenderPass2),
3501         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass2KHR,                                                    cmdBeginRenderPass2),
3502         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass2KHR,                                                                cmdNextSubpass2),
3503         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass2KHR,                                                              cmdEndRenderPass2),
3504         VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR,                                                             getSwapchainStatusKHR),
3505         VK_NULL_FUNC_ENTRY(vkImportFenceFdKHR,                                                                  importFenceFdKHR),
3506         VK_NULL_FUNC_ENTRY(vkGetFenceFdKHR,                                                                             getFenceFdKHR),
3507         VK_NULL_FUNC_ENTRY(vkAcquireProfilingLockKHR,                                                   acquireProfilingLockKHR),
3508         VK_NULL_FUNC_ENTRY(vkReleaseProfilingLockKHR,                                                   releaseProfilingLockKHR),
3509         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2KHR,                                    getImageMemoryRequirements2),
3510         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2KHR,                                   getBufferMemoryRequirements2),
3511         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2KHR,                              getImageSparseMemoryRequirements2),
3512         VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversionKHR,                                   createSamplerYcbcrConversion),
3513         VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversionKHR,                                  destroySamplerYcbcrConversion),
3514         VK_NULL_FUNC_ENTRY(vkBindBufferMemory2KHR,                                                              bindBufferMemory2),
3515         VK_NULL_FUNC_ENTRY(vkBindImageMemory2KHR,                                                               bindImageMemory2),
3516         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupportKHR,                                  getDescriptorSetLayoutSupport),
3517         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountKHR,                                                   cmdDrawIndirectCount),
3518         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountKHR,                                    cmdDrawIndexedIndirectCount),
3519         VK_NULL_FUNC_ENTRY(vkGetSemaphoreCounterValueKHR,                                               getSemaphoreCounterValue),
3520         VK_NULL_FUNC_ENTRY(vkWaitSemaphoresKHR,                                                                 waitSemaphores),
3521         VK_NULL_FUNC_ENTRY(vkSignalSemaphoreKHR,                                                                signalSemaphore),
3522         VK_NULL_FUNC_ENTRY(vkCmdSetFragmentShadingRateKHR,                                              cmdSetFragmentShadingRateKHR),
3523         VK_NULL_FUNC_ENTRY(vkWaitForPresentKHR,                                                                 waitForPresentKHR),
3524         VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddressKHR,                                                 getBufferDeviceAddress),
3525         VK_NULL_FUNC_ENTRY(vkGetBufferOpaqueCaptureAddressKHR,                                  getBufferOpaqueCaptureAddress),
3526         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryOpaqueCaptureAddressKHR,                    getDeviceMemoryOpaqueCaptureAddress),
3527         VK_NULL_FUNC_ENTRY(vkCreateDeferredOperationKHR,                                                createDeferredOperationKHR),
3528         VK_NULL_FUNC_ENTRY(vkDestroyDeferredOperationKHR,                                               destroyDeferredOperationKHR),
3529         VK_NULL_FUNC_ENTRY(vkGetDeferredOperationMaxConcurrencyKHR,                             getDeferredOperationMaxConcurrencyKHR),
3530         VK_NULL_FUNC_ENTRY(vkGetDeferredOperationResultKHR,                                             getDeferredOperationResultKHR),
3531         VK_NULL_FUNC_ENTRY(vkDeferredOperationJoinKHR,                                                  deferredOperationJoinKHR),
3532         VK_NULL_FUNC_ENTRY(vkGetPipelineExecutablePropertiesKHR,                                getPipelineExecutablePropertiesKHR),
3533         VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableStatisticsKHR,                                getPipelineExecutableStatisticsKHR),
3534         VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableInternalRepresentationsKHR,   getPipelineExecutableInternalRepresentationsKHR),
3535         VK_NULL_FUNC_ENTRY(vkCmdSetEvent2KHR,                                                                   cmdSetEvent2KHR),
3536         VK_NULL_FUNC_ENTRY(vkCmdResetEvent2KHR,                                                                 cmdResetEvent2KHR),
3537         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents2KHR,                                                                 cmdWaitEvents2KHR),
3538         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier2KHR,                                                    cmdPipelineBarrier2KHR),
3539         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp2KHR,                                                             cmdWriteTimestamp2KHR),
3540         VK_NULL_FUNC_ENTRY(vkQueueSubmit2KHR,                                                                   queueSubmit2KHR),
3541         VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarker2AMD,                                                  cmdWriteBufferMarker2AMD),
3542         VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointData2NV,                                                 getQueueCheckpointData2NV),
3543         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer2KHR,                                                                 cmdCopyBuffer2KHR),
3544         VK_NULL_FUNC_ENTRY(vkCmdCopyImage2KHR,                                                                  cmdCopyImage2KHR),
3545         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage2KHR,                                                  cmdCopyBufferToImage2KHR),
3546         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer2KHR,                                                  cmdCopyImageToBuffer2KHR),
3547         VK_NULL_FUNC_ENTRY(vkCmdBlitImage2KHR,                                                                  cmdBlitImage2KHR),
3548         VK_NULL_FUNC_ENTRY(vkCmdResolveImage2KHR,                                                               cmdResolveImage2KHR),
3549         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectTagEXT,                                                debugMarkerSetObjectTagEXT),
3550         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectNameEXT,                                               debugMarkerSetObjectNameEXT),
3551         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerBeginEXT,                                                    cmdDebugMarkerBeginEXT),
3552         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerEndEXT,                                                              cmdDebugMarkerEndEXT),
3553         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerInsertEXT,                                                   cmdDebugMarkerInsertEXT),
3554         VK_NULL_FUNC_ENTRY(vkCmdBindTransformFeedbackBuffersEXT,                                cmdBindTransformFeedbackBuffersEXT),
3555         VK_NULL_FUNC_ENTRY(vkCmdBeginTransformFeedbackEXT,                                              cmdBeginTransformFeedbackEXT),
3556         VK_NULL_FUNC_ENTRY(vkCmdEndTransformFeedbackEXT,                                                cmdEndTransformFeedbackEXT),
3557         VK_NULL_FUNC_ENTRY(vkCmdBeginQueryIndexedEXT,                                                   cmdBeginQueryIndexedEXT),
3558         VK_NULL_FUNC_ENTRY(vkCmdEndQueryIndexedEXT,                                                             cmdEndQueryIndexedEXT),
3559         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectByteCountEXT,                                               cmdDrawIndirectByteCountEXT),
3560         VK_NULL_FUNC_ENTRY(vkCreateCuModuleNVX,                                                                 createCuModuleNVX),
3561         VK_NULL_FUNC_ENTRY(vkCreateCuFunctionNVX,                                                               createCuFunctionNVX),
3562         VK_NULL_FUNC_ENTRY(vkDestroyCuModuleNVX,                                                                destroyCuModuleNVX),
3563         VK_NULL_FUNC_ENTRY(vkDestroyCuFunctionNVX,                                                              destroyCuFunctionNVX),
3564         VK_NULL_FUNC_ENTRY(vkCmdCuLaunchKernelNVX,                                                              cmdCuLaunchKernelNVX),
3565         VK_NULL_FUNC_ENTRY(vkGetImageViewHandleNVX,                                                             getImageViewHandleNVX),
3566         VK_NULL_FUNC_ENTRY(vkGetImageViewAddressNVX,                                                    getImageViewAddressNVX),
3567         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountAMD,                                                   cmdDrawIndirectCountAMD),
3568         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountAMD,                                    cmdDrawIndexedIndirectCountAMD),
3569         VK_NULL_FUNC_ENTRY(vkGetShaderInfoAMD,                                                                  getShaderInfoAMD),
3570         VK_NULL_FUNC_ENTRY(vkCmdBeginConditionalRenderingEXT,                                   cmdBeginConditionalRenderingEXT),
3571         VK_NULL_FUNC_ENTRY(vkCmdEndConditionalRenderingEXT,                                             cmdEndConditionalRenderingEXT),
3572         VK_NULL_FUNC_ENTRY(vkCmdSetViewportWScalingNV,                                                  cmdSetViewportWScalingNV),
3573         VK_NULL_FUNC_ENTRY(vkDisplayPowerControlEXT,                                                    displayPowerControlEXT),
3574         VK_NULL_FUNC_ENTRY(vkRegisterDeviceEventEXT,                                                    registerDeviceEventEXT),
3575         VK_NULL_FUNC_ENTRY(vkRegisterDisplayEventEXT,                                                   registerDisplayEventEXT),
3576         VK_NULL_FUNC_ENTRY(vkGetSwapchainCounterEXT,                                                    getSwapchainCounterEXT),
3577         VK_NULL_FUNC_ENTRY(vkGetRefreshCycleDurationGOOGLE,                                             getRefreshCycleDurationGOOGLE),
3578         VK_NULL_FUNC_ENTRY(vkGetPastPresentationTimingGOOGLE,                                   getPastPresentationTimingGOOGLE),
3579         VK_NULL_FUNC_ENTRY(vkCmdSetDiscardRectangleEXT,                                                 cmdSetDiscardRectangleEXT),
3580         VK_NULL_FUNC_ENTRY(vkSetHdrMetadataEXT,                                                                 setHdrMetadataEXT),
3581         VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectNameEXT,                                                setDebugUtilsObjectNameEXT),
3582         VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectTagEXT,                                                 setDebugUtilsObjectTagEXT),
3583         VK_NULL_FUNC_ENTRY(vkQueueBeginDebugUtilsLabelEXT,                                              queueBeginDebugUtilsLabelEXT),
3584         VK_NULL_FUNC_ENTRY(vkQueueEndDebugUtilsLabelEXT,                                                queueEndDebugUtilsLabelEXT),
3585         VK_NULL_FUNC_ENTRY(vkQueueInsertDebugUtilsLabelEXT,                                             queueInsertDebugUtilsLabelEXT),
3586         VK_NULL_FUNC_ENTRY(vkCmdBeginDebugUtilsLabelEXT,                                                cmdBeginDebugUtilsLabelEXT),
3587         VK_NULL_FUNC_ENTRY(vkCmdEndDebugUtilsLabelEXT,                                                  cmdEndDebugUtilsLabelEXT),
3588         VK_NULL_FUNC_ENTRY(vkCmdInsertDebugUtilsLabelEXT,                                               cmdInsertDebugUtilsLabelEXT),
3589         VK_NULL_FUNC_ENTRY(vkCmdSetSampleLocationsEXT,                                                  cmdSetSampleLocationsEXT),
3590         VK_NULL_FUNC_ENTRY(vkGetImageDrmFormatModifierPropertiesEXT,                    getImageDrmFormatModifierPropertiesEXT),
3591         VK_NULL_FUNC_ENTRY(vkCreateValidationCacheEXT,                                                  createValidationCacheEXT),
3592         VK_NULL_FUNC_ENTRY(vkDestroyValidationCacheEXT,                                                 destroyValidationCacheEXT),
3593         VK_NULL_FUNC_ENTRY(vkMergeValidationCachesEXT,                                                  mergeValidationCachesEXT),
3594         VK_NULL_FUNC_ENTRY(vkGetValidationCacheDataEXT,                                                 getValidationCacheDataEXT),
3595         VK_NULL_FUNC_ENTRY(vkCmdBindShadingRateImageNV,                                                 cmdBindShadingRateImageNV),
3596         VK_NULL_FUNC_ENTRY(vkCmdSetViewportShadingRatePaletteNV,                                cmdSetViewportShadingRatePaletteNV),
3597         VK_NULL_FUNC_ENTRY(vkCmdSetCoarseSampleOrderNV,                                                 cmdSetCoarseSampleOrderNV),
3598         VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureNV,                                             createAccelerationStructureNV),
3599         VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureNV,                                    destroyAccelerationStructureNV),
3600         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureMemoryRequirementsNV,              getAccelerationStructureMemoryRequirementsNV),
3601         VK_NULL_FUNC_ENTRY(vkBindAccelerationStructureMemoryNV,                                 bindAccelerationStructureMemoryNV),
3602         VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructureNV,                                   cmdBuildAccelerationStructureNV),
3603         VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureNV,                                    cmdCopyAccelerationStructureNV),
3604         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysNV,                                                                    cmdTraceRaysNV),
3605         VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesNV,                                               createRayTracingPipelinesNV),
3606         VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupHandlesKHR,                                getRayTracingShaderGroupHandlesKHR),
3607         VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupHandlesNV,                                 getRayTracingShaderGroupHandlesNV),
3608         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureHandleNV,                                  getAccelerationStructureHandleNV),
3609         VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesNV,                cmdWriteAccelerationStructuresPropertiesNV),
3610         VK_NULL_FUNC_ENTRY(vkCompileDeferredNV,                                                                 compileDeferredNV),
3611         VK_NULL_FUNC_ENTRY(vkGetMemoryHostPointerPropertiesEXT,                                 getMemoryHostPointerPropertiesEXT),
3612         VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarkerAMD,                                                   cmdWriteBufferMarkerAMD),
3613         VK_NULL_FUNC_ENTRY(vkGetCalibratedTimestampsEXT,                                                getCalibratedTimestampsEXT),
3614         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksNV,                                                                cmdDrawMeshTasksNV),
3615         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectNV,                                                cmdDrawMeshTasksIndirectNV),
3616         VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectCountNV,                                   cmdDrawMeshTasksIndirectCountNV),
3617         VK_NULL_FUNC_ENTRY(vkCmdSetExclusiveScissorNV,                                                  cmdSetExclusiveScissorNV),
3618         VK_NULL_FUNC_ENTRY(vkCmdSetCheckpointNV,                                                                cmdSetCheckpointNV),
3619         VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointDataNV,                                                  getQueueCheckpointDataNV),
3620         VK_NULL_FUNC_ENTRY(vkInitializePerformanceApiINTEL,                                             initializePerformanceApiINTEL),
3621         VK_NULL_FUNC_ENTRY(vkUninitializePerformanceApiINTEL,                                   uninitializePerformanceApiINTEL),
3622         VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceMarkerINTEL,                                              cmdSetPerformanceMarkerINTEL),
3623         VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceStreamMarkerINTEL,                                cmdSetPerformanceStreamMarkerINTEL),
3624         VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceOverrideINTEL,                                    cmdSetPerformanceOverrideINTEL),
3625         VK_NULL_FUNC_ENTRY(vkAcquirePerformanceConfigurationINTEL,                              acquirePerformanceConfigurationINTEL),
3626         VK_NULL_FUNC_ENTRY(vkReleasePerformanceConfigurationINTEL,                              releasePerformanceConfigurationINTEL),
3627         VK_NULL_FUNC_ENTRY(vkQueueSetPerformanceConfigurationINTEL,                             queueSetPerformanceConfigurationINTEL),
3628         VK_NULL_FUNC_ENTRY(vkGetPerformanceParameterINTEL,                                              getPerformanceParameterINTEL),
3629         VK_NULL_FUNC_ENTRY(vkSetLocalDimmingAMD,                                                                setLocalDimmingAMD),
3630         VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddressEXT,                                                 getBufferDeviceAddressEXT),
3631         VK_NULL_FUNC_ENTRY(vkCmdSetLineStippleEXT,                                                              cmdSetLineStippleEXT),
3632         VK_NULL_FUNC_ENTRY(vkResetQueryPoolEXT,                                                                 resetQueryPool),
3633         VK_NULL_FUNC_ENTRY(vkCmdSetCullModeEXT,                                                                 cmdSetCullModeEXT),
3634         VK_NULL_FUNC_ENTRY(vkCmdSetFrontFaceEXT,                                                                cmdSetFrontFaceEXT),
3635         VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveTopologyEXT,                                                cmdSetPrimitiveTopologyEXT),
3636         VK_NULL_FUNC_ENTRY(vkCmdSetViewportWithCountEXT,                                                cmdSetViewportWithCountEXT),
3637         VK_NULL_FUNC_ENTRY(vkCmdSetScissorWithCountEXT,                                                 cmdSetScissorWithCountEXT),
3638         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers2EXT,                                                  cmdBindVertexBuffers2EXT),
3639         VK_NULL_FUNC_ENTRY(vkCmdSetDepthTestEnableEXT,                                                  cmdSetDepthTestEnableEXT),
3640         VK_NULL_FUNC_ENTRY(vkCmdSetDepthWriteEnableEXT,                                                 cmdSetDepthWriteEnableEXT),
3641         VK_NULL_FUNC_ENTRY(vkCmdSetDepthCompareOpEXT,                                                   cmdSetDepthCompareOpEXT),
3642         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBoundsTestEnableEXT,                                    cmdSetDepthBoundsTestEnableEXT),
3643         VK_NULL_FUNC_ENTRY(vkCmdSetStencilTestEnableEXT,                                                cmdSetStencilTestEnableEXT),
3644         VK_NULL_FUNC_ENTRY(vkCmdSetStencilOpEXT,                                                                cmdSetStencilOpEXT),
3645         VK_NULL_FUNC_ENTRY(vkGetGeneratedCommandsMemoryRequirementsNV,                  getGeneratedCommandsMemoryRequirementsNV),
3646         VK_NULL_FUNC_ENTRY(vkCmdPreprocessGeneratedCommandsNV,                                  cmdPreprocessGeneratedCommandsNV),
3647         VK_NULL_FUNC_ENTRY(vkCmdExecuteGeneratedCommandsNV,                                             cmdExecuteGeneratedCommandsNV),
3648         VK_NULL_FUNC_ENTRY(vkCmdBindPipelineShaderGroupNV,                                              cmdBindPipelineShaderGroupNV),
3649         VK_NULL_FUNC_ENTRY(vkCreateIndirectCommandsLayoutNV,                                    createIndirectCommandsLayoutNV),
3650         VK_NULL_FUNC_ENTRY(vkDestroyIndirectCommandsLayoutNV,                                   destroyIndirectCommandsLayoutNV),
3651         VK_NULL_FUNC_ENTRY(vkCreatePrivateDataSlotEXT,                                                  createPrivateDataSlotEXT),
3652         VK_NULL_FUNC_ENTRY(vkDestroyPrivateDataSlotEXT,                                                 destroyPrivateDataSlotEXT),
3653         VK_NULL_FUNC_ENTRY(vkSetPrivateDataEXT,                                                                 setPrivateDataEXT),
3654         VK_NULL_FUNC_ENTRY(vkGetPrivateDataEXT,                                                                 getPrivateDataEXT),
3655         VK_NULL_FUNC_ENTRY(vkCmdSetFragmentShadingRateEnumNV,                                   cmdSetFragmentShadingRateEnumNV),
3656         VK_NULL_FUNC_ENTRY(vkCmdSetVertexInputEXT,                                                              cmdSetVertexInputEXT),
3657         VK_NULL_FUNC_ENTRY(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,             getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI),
3658         VK_NULL_FUNC_ENTRY(vkCmdSubpassShadingHUAWEI,                                                   cmdSubpassShadingHUAWEI),
3659         VK_NULL_FUNC_ENTRY(vkCmdBindInvocationMaskHUAWEI,                                               cmdBindInvocationMaskHUAWEI),
3660         VK_NULL_FUNC_ENTRY(vkGetMemoryRemoteAddressNV,                                                  getMemoryRemoteAddressNV),
3661         VK_NULL_FUNC_ENTRY(vkCmdSetPatchControlPointsEXT,                                               cmdSetPatchControlPointsEXT),
3662         VK_NULL_FUNC_ENTRY(vkCmdSetRasterizerDiscardEnableEXT,                                  cmdSetRasterizerDiscardEnableEXT),
3663         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBiasEnableEXT,                                                  cmdSetDepthBiasEnableEXT),
3664         VK_NULL_FUNC_ENTRY(vkCmdSetLogicOpEXT,                                                                  cmdSetLogicOpEXT),
3665         VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveRestartEnableEXT,                                   cmdSetPrimitiveRestartEnableEXT),
3666         VK_NULL_FUNC_ENTRY(vkCmdSetColorWriteEnableEXT,                                                 cmdSetColorWriteEnableEXT),
3667         VK_NULL_FUNC_ENTRY(vkCmdDrawMultiEXT,                                                                   cmdDrawMultiEXT),
3668         VK_NULL_FUNC_ENTRY(vkCmdDrawMultiIndexedEXT,                                                    cmdDrawMultiIndexedEXT),
3669         VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureKHR,                                    createAccelerationStructureKHR),
3670         VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureKHR,                                   destroyAccelerationStructureKHR),
3671         VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructuresKHR,                                 cmdBuildAccelerationStructuresKHR),
3672         VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructuresIndirectKHR,                 cmdBuildAccelerationStructuresIndirectKHR),
3673         VK_NULL_FUNC_ENTRY(vkBuildAccelerationStructuresKHR,                                    buildAccelerationStructuresKHR),
3674         VK_NULL_FUNC_ENTRY(vkCopyAccelerationStructureKHR,                                              copyAccelerationStructureKHR),
3675         VK_NULL_FUNC_ENTRY(vkCopyAccelerationStructureToMemoryKHR,                              copyAccelerationStructureToMemoryKHR),
3676         VK_NULL_FUNC_ENTRY(vkCopyMemoryToAccelerationStructureKHR,                              copyMemoryToAccelerationStructureKHR),
3677         VK_NULL_FUNC_ENTRY(vkWriteAccelerationStructuresPropertiesKHR,                  writeAccelerationStructuresPropertiesKHR),
3678         VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureKHR,                                   cmdCopyAccelerationStructureKHR),
3679         VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureToMemoryKHR,                   cmdCopyAccelerationStructureToMemoryKHR),
3680         VK_NULL_FUNC_ENTRY(vkCmdCopyMemoryToAccelerationStructureKHR,                   cmdCopyMemoryToAccelerationStructureKHR),
3681         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureDeviceAddressKHR,                  getAccelerationStructureDeviceAddressKHR),
3682         VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesKHR,               cmdWriteAccelerationStructuresPropertiesKHR),
3683         VK_NULL_FUNC_ENTRY(vkGetDeviceAccelerationStructureCompatibilityKHR,    getDeviceAccelerationStructureCompatibilityKHR),
3684         VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureBuildSizesKHR,                             getAccelerationStructureBuildSizesKHR),
3685         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysKHR,                                                                   cmdTraceRaysKHR),
3686         VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesKHR,                                              createRayTracingPipelinesKHR),
3687         VK_NULL_FUNC_ENTRY(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,   getRayTracingCaptureReplayShaderGroupHandlesKHR),
3688         VK_NULL_FUNC_ENTRY(vkCmdTraceRaysIndirectKHR,                                                   cmdTraceRaysIndirectKHR),
3689         VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupStackSizeKHR,                              getRayTracingShaderGroupStackSizeKHR),
3690         VK_NULL_FUNC_ENTRY(vkCmdSetRayTracingPipelineStackSizeKHR,                              cmdSetRayTracingPipelineStackSizeKHR),
3691         VK_NULL_FUNC_ENTRY(vkGetAndroidHardwareBufferPropertiesANDROID,                 getAndroidHardwareBufferPropertiesANDROID),
3692         VK_NULL_FUNC_ENTRY(vkGetMemoryAndroidHardwareBufferANDROID,                             getMemoryAndroidHardwareBufferANDROID),
3693         VK_NULL_FUNC_ENTRY(vkCreateVideoSessionKHR,                                                             createVideoSessionKHR),
3694         VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionKHR,                                                    destroyVideoSessionKHR),
3695         VK_NULL_FUNC_ENTRY(vkGetVideoSessionMemoryRequirementsKHR,                              getVideoSessionMemoryRequirementsKHR),
3696         VK_NULL_FUNC_ENTRY(vkBindVideoSessionMemoryKHR,                                                 bindVideoSessionMemoryKHR),
3697         VK_NULL_FUNC_ENTRY(vkCreateVideoSessionParametersKHR,                                   createVideoSessionParametersKHR),
3698         VK_NULL_FUNC_ENTRY(vkUpdateVideoSessionParametersKHR,                                   updateVideoSessionParametersKHR),
3699         VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionParametersKHR,                                  destroyVideoSessionParametersKHR),
3700         VK_NULL_FUNC_ENTRY(vkCmdBeginVideoCodingKHR,                                                    cmdBeginVideoCodingKHR),
3701         VK_NULL_FUNC_ENTRY(vkCmdEndVideoCodingKHR,                                                              cmdEndVideoCodingKHR),
3702         VK_NULL_FUNC_ENTRY(vkCmdControlVideoCodingKHR,                                                  cmdControlVideoCodingKHR),
3703         VK_NULL_FUNC_ENTRY(vkCmdDecodeVideoKHR,                                                                 cmdDecodeVideoKHR),
3704         VK_NULL_FUNC_ENTRY(vkCmdEncodeVideoKHR,                                                                 cmdEncodeVideoKHR),
3705         VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandleFUCHSIA,                                              getMemoryZirconHandleFUCHSIA),
3706         VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandlePropertiesFUCHSIA,                    getMemoryZirconHandlePropertiesFUCHSIA),
3707         VK_NULL_FUNC_ENTRY(vkImportSemaphoreZirconHandleFUCHSIA,                                importSemaphoreZirconHandleFUCHSIA),
3708         VK_NULL_FUNC_ENTRY(vkGetSemaphoreZirconHandleFUCHSIA,                                   getSemaphoreZirconHandleFUCHSIA),
3709         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHR,                                                   getMemoryWin32HandleKHR),
3710         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHR,                                 getMemoryWin32HandlePropertiesKHR),
3711         VK_NULL_FUNC_ENTRY(vkImportSemaphoreWin32HandleKHR,                                             importSemaphoreWin32HandleKHR),
3712         VK_NULL_FUNC_ENTRY(vkGetSemaphoreWin32HandleKHR,                                                getSemaphoreWin32HandleKHR),
3713         VK_NULL_FUNC_ENTRY(vkImportFenceWin32HandleKHR,                                                 importFenceWin32HandleKHR),
3714         VK_NULL_FUNC_ENTRY(vkGetFenceWin32HandleKHR,                                                    getFenceWin32HandleKHR),
3715         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleNV,                                                    getMemoryWin32HandleNV),
3716         VK_NULL_FUNC_ENTRY(vkAcquireFullScreenExclusiveModeEXT,                                 acquireFullScreenExclusiveModeEXT),
3717         VK_NULL_FUNC_ENTRY(vkReleaseFullScreenExclusiveModeEXT,                                 releaseFullScreenExclusiveModeEXT),
3718         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModes2EXT,                             getDeviceGroupSurfacePresentModes2EXT),
3719 };
3720