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 createSwapchainKHR (VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
 131 {
 132         DE_UNREF(pAllocator);
 133         VK_NULL_RETURN((*pSwapchain = allocateNonDispHandle<SwapchainKHR, VkSwapchainKHR>(device, pCreateInfo, pAllocator)));
 134 }
 135
 136 VKAPI_ATTR VkResult VKAPI_CALL createDisplayPlaneSurfaceKHR (VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 137 {
 138         DE_UNREF(pAllocator);
 139         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 140 }
 141
 142 VKAPI_ATTR VkResult VKAPI_CALL createXlibSurfaceKHR (VkInstance instance, const VkXlibSurfaceCreateInfoKHR* 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 createXcbSurfaceKHR (VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 149 {
 150         DE_UNREF(pAllocator);
 151         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 152 }
 153
 154 VKAPI_ATTR VkResult VKAPI_CALL createWaylandSurfaceKHR (VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 155 {
 156         DE_UNREF(pAllocator);
 157         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 158 }
 159
 160 VKAPI_ATTR VkResult VKAPI_CALL createMirSurfaceKHR (VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 161 {
 162         DE_UNREF(pAllocator);
 163         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 164 }
 165
 166 VKAPI_ATTR VkResult VKAPI_CALL createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 167 {
 168         DE_UNREF(pAllocator);
 169         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 170 }
 171
 172 VKAPI_ATTR VkResult VKAPI_CALL createWin32SurfaceKHR (VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 173 {
 174         DE_UNREF(pAllocator);
 175         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 176 }
 177
 178 VKAPI_ATTR VkResult VKAPI_CALL createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback)
 179 {
 180         DE_UNREF(pAllocator);
 181         VK_NULL_RETURN((*pCallback = allocateNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(instance, pCreateInfo, pAllocator)));
 182 }
 183
 184 VKAPI_ATTR VkResult VKAPI_CALL createViSurfaceNN (VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 185 {
 186         DE_UNREF(pAllocator);
 187         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 188 }
 189
 190 VKAPI_ATTR VkResult VKAPI_CALL createIndirectCommandsLayoutNVX (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
 191 {
 192         DE_UNREF(pAllocator);
 193         VK_NULL_RETURN((*pIndirectCommandsLayout = allocateNonDispHandle<IndirectCommandsLayoutNVX, VkIndirectCommandsLayoutNVX>(device, pCreateInfo, pAllocator)));
 194 }
 195
 196 VKAPI_ATTR VkResult VKAPI_CALL createObjectTableNVX (VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable)
 197 {
 198         DE_UNREF(pAllocator);
 199         VK_NULL_RETURN((*pObjectTable = allocateNonDispHandle<ObjectTableNVX, VkObjectTableNVX>(device, pCreateInfo, pAllocator)));
 200 }
 201
 202 VKAPI_ATTR VkResult VKAPI_CALL createIOSSurfaceMVK (VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 203 {
 204         DE_UNREF(pAllocator);
 205         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 206 }
 207
 208 VKAPI_ATTR VkResult VKAPI_CALL createMacOSSurfaceMVK (VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 209 {
 210         DE_UNREF(pAllocator);
 211         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 212 }
 213
 214 VKAPI_ATTR VkResult VKAPI_CALL createValidationCacheEXT (VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache)
 215 {
 216         DE_UNREF(pAllocator);
 217         VK_NULL_RETURN((*pValidationCache = allocateNonDispHandle<ValidationCacheEXT, VkValidationCacheEXT>(device, pCreateInfo, pAllocator)));
 218 }
 219
 220 VKAPI_ATTR void VKAPI_CALL destroyInstance (VkInstance instance, const VkAllocationCallbacks* pAllocator)
 221 {
 222         freeHandle<Instance, VkInstance>(instance, pAllocator);
 223 }
 224
 225 VKAPI_ATTR void VKAPI_CALL destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator)
 226 {
 227         freeHandle<Device, VkDevice>(device, pAllocator);
 228 }
 229
 230 VKAPI_ATTR void VKAPI_CALL freeMemory (VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
 231 {
 232         DE_UNREF(device);
 233         freeNonDispHandle<DeviceMemory, VkDeviceMemory>(memory, pAllocator);
 234 }
 235
 236 VKAPI_ATTR void VKAPI_CALL destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
 237 {
 238         DE_UNREF(device);
 239         freeNonDispHandle<Fence, VkFence>(fence, pAllocator);
 240 }
 241
 242 VKAPI_ATTR void VKAPI_CALL destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
 243 {
 244         DE_UNREF(device);
 245         freeNonDispHandle<Semaphore, VkSemaphore>(semaphore, pAllocator);
 246 }
 247
 248 VKAPI_ATTR void VKAPI_CALL destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
 249 {
 250         DE_UNREF(device);
 251         freeNonDispHandle<Event, VkEvent>(event, pAllocator);
 252 }
 253
 254 VKAPI_ATTR void VKAPI_CALL destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
 255 {
 256         DE_UNREF(device);
 257         freeNonDispHandle<QueryPool, VkQueryPool>(queryPool, pAllocator);
 258 }
 259
 260 VKAPI_ATTR void VKAPI_CALL destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
 261 {
 262         DE_UNREF(device);
 263         freeNonDispHandle<Buffer, VkBuffer>(buffer, pAllocator);
 264 }
 265
 266 VKAPI_ATTR void VKAPI_CALL destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
 267 {
 268         DE_UNREF(device);
 269         freeNonDispHandle<BufferView, VkBufferView>(bufferView, pAllocator);
 270 }
 271
 272 VKAPI_ATTR void VKAPI_CALL destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 273 {
 274         DE_UNREF(device);
 275         freeNonDispHandle<Image, VkImage>(image, pAllocator);
 276 }
 277
 278 VKAPI_ATTR void VKAPI_CALL destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
 279 {
 280         DE_UNREF(device);
 281         freeNonDispHandle<ImageView, VkImageView>(imageView, pAllocator);
 282 }
 283
 284 VKAPI_ATTR void VKAPI_CALL destroyShaderModule (VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
 285 {
 286         DE_UNREF(device);
 287         freeNonDispHandle<ShaderModule, VkShaderModule>(shaderModule, pAllocator);
 288 }
 289
 290 VKAPI_ATTR void VKAPI_CALL destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
 291 {
 292         DE_UNREF(device);
 293         freeNonDispHandle<PipelineCache, VkPipelineCache>(pipelineCache, pAllocator);
 294 }
 295
 296 VKAPI_ATTR void VKAPI_CALL destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
 297 {
 298         DE_UNREF(device);
 299         freeNonDispHandle<Pipeline, VkPipeline>(pipeline, pAllocator);
 300 }
 301
 302 VKAPI_ATTR void VKAPI_CALL destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
 303 {
 304         DE_UNREF(device);
 305         freeNonDispHandle<PipelineLayout, VkPipelineLayout>(pipelineLayout, pAllocator);
 306 }
 307
 308 VKAPI_ATTR void VKAPI_CALL destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
 309 {
 310         DE_UNREF(device);
 311         freeNonDispHandle<Sampler, VkSampler>(sampler, pAllocator);
 312 }
 313
 314 VKAPI_ATTR void VKAPI_CALL destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
 315 {
 316         DE_UNREF(device);
 317         freeNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(descriptorSetLayout, pAllocator);
 318 }
 319
 320 VKAPI_ATTR void VKAPI_CALL destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
 321 {
 322         DE_UNREF(device);
 323         freeNonDispHandle<DescriptorPool, VkDescriptorPool>(descriptorPool, pAllocator);
 324 }
 325
 326 VKAPI_ATTR void VKAPI_CALL destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
 327 {
 328         DE_UNREF(device);
 329         freeNonDispHandle<Framebuffer, VkFramebuffer>(framebuffer, pAllocator);
 330 }
 331
 332 VKAPI_ATTR void VKAPI_CALL destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
 333 {
 334         DE_UNREF(device);
 335         freeNonDispHandle<RenderPass, VkRenderPass>(renderPass, pAllocator);
 336 }
 337
 338 VKAPI_ATTR void VKAPI_CALL destroyCommandPool (VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
 339 {
 340         DE_UNREF(device);
 341         freeNonDispHandle<CommandPool, VkCommandPool>(commandPool, pAllocator);
 342 }
 343
 344 VKAPI_ATTR void VKAPI_CALL destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
 345 {
 346         DE_UNREF(device);
 347         freeNonDispHandle<SamplerYcbcrConversion, VkSamplerYcbcrConversion>(ycbcrConversion, pAllocator);
 348 }
 349
 350 VKAPI_ATTR void VKAPI_CALL destroyDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
 351 {
 352         DE_UNREF(device);
 353         freeNonDispHandle<DescriptorUpdateTemplate, VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, pAllocator);
 354 }
 355
 356 VKAPI_ATTR void VKAPI_CALL destroySurfaceKHR (VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator)
 357 {
 358         DE_UNREF(instance);
 359         freeNonDispHandle<SurfaceKHR, VkSurfaceKHR>(surface, pAllocator);
 360 }
 361
 362 VKAPI_ATTR void VKAPI_CALL destroySwapchainKHR (VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
 363 {
 364         DE_UNREF(device);
 365         freeNonDispHandle<SwapchainKHR, VkSwapchainKHR>(swapchain, pAllocator);
 366 }
 367
 368 VKAPI_ATTR void VKAPI_CALL destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator)
 369 {
 370         DE_UNREF(instance);
 371         freeNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(callback, pAllocator);
 372 }
 373
 374 VKAPI_ATTR void VKAPI_CALL destroyIndirectCommandsLayoutNVX (VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator)
 375 {
 376         DE_UNREF(device);
 377         freeNonDispHandle<IndirectCommandsLayoutNVX, VkIndirectCommandsLayoutNVX>(indirectCommandsLayout, pAllocator);
 378 }
 379
 380 VKAPI_ATTR void VKAPI_CALL destroyObjectTableNVX (VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator)
 381 {
 382         DE_UNREF(device);
 383         freeNonDispHandle<ObjectTableNVX, VkObjectTableNVX>(objectTable, pAllocator);
 384 }
 385
 386 VKAPI_ATTR void VKAPI_CALL destroyValidationCacheEXT (VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator)
 387 {
 388         DE_UNREF(device);
 389         freeNonDispHandle<ValidationCacheEXT, VkValidationCacheEXT>(validationCache, pAllocator);
 390 }
 391
 392 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (deUint32* pPropertyCount, VkLayerProperties* pProperties)
 393 {
 394         DE_UNREF(pPropertyCount);
 395         DE_UNREF(pProperties);
 396         return VK_SUCCESS;
 397 }
 398
 399 VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkLayerProperties* pProperties)
 400 {
 401         DE_UNREF(physicalDevice);
 402         DE_UNREF(pPropertyCount);
 403         DE_UNREF(pProperties);
 404         return VK_SUCCESS;
 405 }
 406
 407 VKAPI_ATTR VkResult VKAPI_CALL queueSubmit (VkQueue queue, deUint32 submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
 408 {
 409         DE_UNREF(queue);
 410         DE_UNREF(submitCount);
 411         DE_UNREF(pSubmits);
 412         DE_UNREF(fence);
 413         return VK_SUCCESS;
 414 }
 415
 416 VKAPI_ATTR VkResult VKAPI_CALL queueWaitIdle (VkQueue queue)
 417 {
 418         DE_UNREF(queue);
 419         return VK_SUCCESS;
 420 }
 421
 422 VKAPI_ATTR VkResult VKAPI_CALL deviceWaitIdle (VkDevice device)
 423 {
 424         DE_UNREF(device);
 425         return VK_SUCCESS;
 426 }
 427
 428 VKAPI_ATTR VkResult VKAPI_CALL flushMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 429 {
 430         DE_UNREF(device);
 431         DE_UNREF(memoryRangeCount);
 432         DE_UNREF(pMemoryRanges);
 433         return VK_SUCCESS;
 434 }
 435
 436 VKAPI_ATTR VkResult VKAPI_CALL invalidateMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 437 {
 438         DE_UNREF(device);
 439         DE_UNREF(memoryRangeCount);
 440         DE_UNREF(pMemoryRanges);
 441         return VK_SUCCESS;
 442 }
 443
 444 VKAPI_ATTR void VKAPI_CALL getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
 445 {
 446         DE_UNREF(device);
 447         DE_UNREF(memory);
 448         DE_UNREF(pCommittedMemoryInBytes);
 449 }
 450
 451 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 452 {
 453         DE_UNREF(device);
 454         DE_UNREF(buffer);
 455         DE_UNREF(memory);
 456         DE_UNREF(memoryOffset);
 457         return VK_SUCCESS;
 458 }
 459
 460 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 461 {
 462         DE_UNREF(device);
 463         DE_UNREF(image);
 464         DE_UNREF(memory);
 465         DE_UNREF(memoryOffset);
 466         return VK_SUCCESS;
 467 }
 468
 469 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements (VkDevice device, VkImage image, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 470 {
 471         DE_UNREF(device);
 472         DE_UNREF(image);
 473         DE_UNREF(pSparseMemoryRequirementCount);
 474         DE_UNREF(pSparseMemoryRequirements);
 475 }
 476
 477 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, deUint32* pPropertyCount, VkSparseImageFormatProperties* pProperties)
 478 {
 479         DE_UNREF(physicalDevice);
 480         DE_UNREF(format);
 481         DE_UNREF(type);
 482         DE_UNREF(samples);
 483         DE_UNREF(usage);
 484         DE_UNREF(tiling);
 485         DE_UNREF(pPropertyCount);
 486         DE_UNREF(pProperties);
 487 }
 488
 489 VKAPI_ATTR VkResult VKAPI_CALL queueBindSparse (VkQueue queue, deUint32 bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
 490 {
 491         DE_UNREF(queue);
 492         DE_UNREF(bindInfoCount);
 493         DE_UNREF(pBindInfo);
 494         DE_UNREF(fence);
 495         return VK_SUCCESS;
 496 }
 497
 498 VKAPI_ATTR VkResult VKAPI_CALL resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences)
 499 {
 500         DE_UNREF(device);
 501         DE_UNREF(fenceCount);
 502         DE_UNREF(pFences);
 503         return VK_SUCCESS;
 504 }
 505
 506 VKAPI_ATTR VkResult VKAPI_CALL getFenceStatus (VkDevice device, VkFence fence)
 507 {
 508         DE_UNREF(device);
 509         DE_UNREF(fence);
 510         return VK_SUCCESS;
 511 }
 512
 513 VKAPI_ATTR VkResult VKAPI_CALL waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout)
 514 {
 515         DE_UNREF(device);
 516         DE_UNREF(fenceCount);
 517         DE_UNREF(pFences);
 518         DE_UNREF(waitAll);
 519         DE_UNREF(timeout);
 520         return VK_SUCCESS;
 521 }
 522
 523 VKAPI_ATTR VkResult VKAPI_CALL getEventStatus (VkDevice device, VkEvent event)
 524 {
 525         DE_UNREF(device);
 526         DE_UNREF(event);
 527         return VK_SUCCESS;
 528 }
 529
 530 VKAPI_ATTR VkResult VKAPI_CALL setEvent (VkDevice device, VkEvent event)
 531 {
 532         DE_UNREF(device);
 533         DE_UNREF(event);
 534         return VK_SUCCESS;
 535 }
 536
 537 VKAPI_ATTR VkResult VKAPI_CALL resetEvent (VkDevice device, VkEvent event)
 538 {
 539         DE_UNREF(device);
 540         DE_UNREF(event);
 541         return VK_SUCCESS;
 542 }
 543
 544 VKAPI_ATTR VkResult VKAPI_CALL getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
 545 {
 546         DE_UNREF(device);
 547         DE_UNREF(queryPool);
 548         DE_UNREF(firstQuery);
 549         DE_UNREF(queryCount);
 550         DE_UNREF(dataSize);
 551         DE_UNREF(pData);
 552         DE_UNREF(stride);
 553         DE_UNREF(flags);
 554         return VK_SUCCESS;
 555 }
 556
 557 VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
 558 {
 559         DE_UNREF(device);
 560         DE_UNREF(image);
 561         DE_UNREF(pSubresource);
 562         DE_UNREF(pLayout);
 563 }
 564
 565 VKAPI_ATTR VkResult VKAPI_CALL getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, deUintptr* pDataSize, void* pData)
 566 {
 567         DE_UNREF(device);
 568         DE_UNREF(pipelineCache);
 569         DE_UNREF(pDataSize);
 570         DE_UNREF(pData);
 571         return VK_SUCCESS;
 572 }
 573
 574 VKAPI_ATTR VkResult VKAPI_CALL mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches)
 575 {
 576         DE_UNREF(device);
 577         DE_UNREF(dstCache);
 578         DE_UNREF(srcCacheCount);
 579         DE_UNREF(pSrcCaches);
 580         return VK_SUCCESS;
 581 }
 582
 583 VKAPI_ATTR void VKAPI_CALL updateDescriptorSets (VkDevice device, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
 584 {
 585         DE_UNREF(device);
 586         DE_UNREF(descriptorWriteCount);
 587         DE_UNREF(pDescriptorWrites);
 588         DE_UNREF(descriptorCopyCount);
 589         DE_UNREF(pDescriptorCopies);
 590 }
 591
 592 VKAPI_ATTR void VKAPI_CALL getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
 593 {
 594         DE_UNREF(device);
 595         DE_UNREF(renderPass);
 596         DE_UNREF(pGranularity);
 597 }
 598
 599 VKAPI_ATTR VkResult VKAPI_CALL resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 600 {
 601         DE_UNREF(device);
 602         DE_UNREF(commandPool);
 603         DE_UNREF(flags);
 604         return VK_SUCCESS;
 605 }
 606
 607 VKAPI_ATTR VkResult VKAPI_CALL beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
 608 {
 609         DE_UNREF(commandBuffer);
 610         DE_UNREF(pBeginInfo);
 611         return VK_SUCCESS;
 612 }
 613
 614 VKAPI_ATTR VkResult VKAPI_CALL endCommandBuffer (VkCommandBuffer commandBuffer)
 615 {
 616         DE_UNREF(commandBuffer);
 617         return VK_SUCCESS;
 618 }
 619
 620 VKAPI_ATTR VkResult VKAPI_CALL resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 621 {
 622         DE_UNREF(commandBuffer);
 623         DE_UNREF(flags);
 624         return VK_SUCCESS;
 625 }
 626
 627 VKAPI_ATTR void VKAPI_CALL cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 628 {
 629         DE_UNREF(commandBuffer);
 630         DE_UNREF(pipelineBindPoint);
 631         DE_UNREF(pipeline);
 632 }
 633
 634 VKAPI_ATTR void VKAPI_CALL cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports)
 635 {
 636         DE_UNREF(commandBuffer);
 637         DE_UNREF(firstViewport);
 638         DE_UNREF(viewportCount);
 639         DE_UNREF(pViewports);
 640 }
 641
 642 VKAPI_ATTR void VKAPI_CALL cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors)
 643 {
 644         DE_UNREF(commandBuffer);
 645         DE_UNREF(firstScissor);
 646         DE_UNREF(scissorCount);
 647         DE_UNREF(pScissors);
 648 }
 649
 650 VKAPI_ATTR void VKAPI_CALL cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth)
 651 {
 652         DE_UNREF(commandBuffer);
 653         DE_UNREF(lineWidth);
 654 }
 655
 656 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 657 {
 658         DE_UNREF(commandBuffer);
 659         DE_UNREF(depthBiasConstantFactor);
 660         DE_UNREF(depthBiasClamp);
 661         DE_UNREF(depthBiasSlopeFactor);
 662 }
 663
 664 VKAPI_ATTR void VKAPI_CALL cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4])
 665 {
 666         DE_UNREF(commandBuffer);
 667         DE_UNREF(blendConstants);
 668 }
 669
 670 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 671 {
 672         DE_UNREF(commandBuffer);
 673         DE_UNREF(minDepthBounds);
 674         DE_UNREF(maxDepthBounds);
 675 }
 676
 677 VKAPI_ATTR void VKAPI_CALL cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 compareMask)
 678 {
 679         DE_UNREF(commandBuffer);
 680         DE_UNREF(faceMask);
 681         DE_UNREF(compareMask);
 682 }
 683
 684 VKAPI_ATTR void VKAPI_CALL cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 writeMask)
 685 {
 686         DE_UNREF(commandBuffer);
 687         DE_UNREF(faceMask);
 688         DE_UNREF(writeMask);
 689 }
 690
 691 VKAPI_ATTR void VKAPI_CALL cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 reference)
 692 {
 693         DE_UNREF(commandBuffer);
 694         DE_UNREF(faceMask);
 695         DE_UNREF(reference);
 696 }
 697
 698 VKAPI_ATTR void VKAPI_CALL cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 descriptorSetCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets)
 699 {
 700         DE_UNREF(commandBuffer);
 701         DE_UNREF(pipelineBindPoint);
 702         DE_UNREF(layout);
 703         DE_UNREF(firstSet);
 704         DE_UNREF(descriptorSetCount);
 705         DE_UNREF(pDescriptorSets);
 706         DE_UNREF(dynamicOffsetCount);
 707         DE_UNREF(pDynamicOffsets);
 708 }
 709
 710 VKAPI_ATTR void VKAPI_CALL cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 711 {
 712         DE_UNREF(commandBuffer);
 713         DE_UNREF(buffer);
 714         DE_UNREF(offset);
 715         DE_UNREF(indexType);
 716 }
 717
 718 VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
 719 {
 720         DE_UNREF(commandBuffer);
 721         DE_UNREF(firstBinding);
 722         DE_UNREF(bindingCount);
 723         DE_UNREF(pBuffers);
 724         DE_UNREF(pOffsets);
 725 }
 726
 727 VKAPI_ATTR void VKAPI_CALL cmdDraw (VkCommandBuffer commandBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance)
 728 {
 729         DE_UNREF(commandBuffer);
 730         DE_UNREF(vertexCount);
 731         DE_UNREF(instanceCount);
 732         DE_UNREF(firstVertex);
 733         DE_UNREF(firstInstance);
 734 }
 735
 736 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexed (VkCommandBuffer commandBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance)
 737 {
 738         DE_UNREF(commandBuffer);
 739         DE_UNREF(indexCount);
 740         DE_UNREF(instanceCount);
 741         DE_UNREF(firstIndex);
 742         DE_UNREF(vertexOffset);
 743         DE_UNREF(firstInstance);
 744 }
 745
 746 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride)
 747 {
 748         DE_UNREF(commandBuffer);
 749         DE_UNREF(buffer);
 750         DE_UNREF(offset);
 751         DE_UNREF(drawCount);
 752         DE_UNREF(stride);
 753 }
 754
 755 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride)
 756 {
 757         DE_UNREF(commandBuffer);
 758         DE_UNREF(buffer);
 759         DE_UNREF(offset);
 760         DE_UNREF(drawCount);
 761         DE_UNREF(stride);
 762 }
 763
 764 VKAPI_ATTR void VKAPI_CALL cmdDispatch (VkCommandBuffer commandBuffer, deUint32 groupCountX, deUint32 groupCountY, deUint32 groupCountZ)
 765 {
 766         DE_UNREF(commandBuffer);
 767         DE_UNREF(groupCountX);
 768         DE_UNREF(groupCountY);
 769         DE_UNREF(groupCountZ);
 770 }
 771
 772 VKAPI_ATTR void VKAPI_CALL cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 773 {
 774         DE_UNREF(commandBuffer);
 775         DE_UNREF(buffer);
 776         DE_UNREF(offset);
 777 }
 778
 779 VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferCopy* pRegions)
 780 {
 781         DE_UNREF(commandBuffer);
 782         DE_UNREF(srcBuffer);
 783         DE_UNREF(dstBuffer);
 784         DE_UNREF(regionCount);
 785         DE_UNREF(pRegions);
 786 }
 787
 788 VKAPI_ATTR void VKAPI_CALL cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageCopy* pRegions)
 789 {
 790         DE_UNREF(commandBuffer);
 791         DE_UNREF(srcImage);
 792         DE_UNREF(srcImageLayout);
 793         DE_UNREF(dstImage);
 794         DE_UNREF(dstImageLayout);
 795         DE_UNREF(regionCount);
 796         DE_UNREF(pRegions);
 797 }
 798
 799 VKAPI_ATTR void VKAPI_CALL cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkFilter filter)
 800 {
 801         DE_UNREF(commandBuffer);
 802         DE_UNREF(srcImage);
 803         DE_UNREF(srcImageLayout);
 804         DE_UNREF(dstImage);
 805         DE_UNREF(dstImageLayout);
 806         DE_UNREF(regionCount);
 807         DE_UNREF(pRegions);
 808         DE_UNREF(filter);
 809 }
 810
 811 VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 812 {
 813         DE_UNREF(commandBuffer);
 814         DE_UNREF(srcBuffer);
 815         DE_UNREF(dstImage);
 816         DE_UNREF(dstImageLayout);
 817         DE_UNREF(regionCount);
 818         DE_UNREF(pRegions);
 819 }
 820
 821 VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 822 {
 823         DE_UNREF(commandBuffer);
 824         DE_UNREF(srcImage);
 825         DE_UNREF(srcImageLayout);
 826         DE_UNREF(dstBuffer);
 827         DE_UNREF(regionCount);
 828         DE_UNREF(pRegions);
 829 }
 830
 831 VKAPI_ATTR void VKAPI_CALL cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
 832 {
 833         DE_UNREF(commandBuffer);
 834         DE_UNREF(dstBuffer);
 835         DE_UNREF(dstOffset);
 836         DE_UNREF(dataSize);
 837         DE_UNREF(pData);
 838 }
 839
 840 VKAPI_ATTR void VKAPI_CALL cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, deUint32 data)
 841 {
 842         DE_UNREF(commandBuffer);
 843         DE_UNREF(dstBuffer);
 844         DE_UNREF(dstOffset);
 845         DE_UNREF(size);
 846         DE_UNREF(data);
 847 }
 848
 849 VKAPI_ATTR void VKAPI_CALL cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 850 {
 851         DE_UNREF(commandBuffer);
 852         DE_UNREF(image);
 853         DE_UNREF(imageLayout);
 854         DE_UNREF(pColor);
 855         DE_UNREF(rangeCount);
 856         DE_UNREF(pRanges);
 857 }
 858
 859 VKAPI_ATTR void VKAPI_CALL cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 860 {
 861         DE_UNREF(commandBuffer);
 862         DE_UNREF(image);
 863         DE_UNREF(imageLayout);
 864         DE_UNREF(pDepthStencil);
 865         DE_UNREF(rangeCount);
 866         DE_UNREF(pRanges);
 867 }
 868
 869 VKAPI_ATTR void VKAPI_CALL cmdClearAttachments (VkCommandBuffer commandBuffer, deUint32 attachmentCount, const VkClearAttachment* pAttachments, deUint32 rectCount, const VkClearRect* pRects)
 870 {
 871         DE_UNREF(commandBuffer);
 872         DE_UNREF(attachmentCount);
 873         DE_UNREF(pAttachments);
 874         DE_UNREF(rectCount);
 875         DE_UNREF(pRects);
 876 }
 877
 878 VKAPI_ATTR void VKAPI_CALL cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageResolve* pRegions)
 879 {
 880         DE_UNREF(commandBuffer);
 881         DE_UNREF(srcImage);
 882         DE_UNREF(srcImageLayout);
 883         DE_UNREF(dstImage);
 884         DE_UNREF(dstImageLayout);
 885         DE_UNREF(regionCount);
 886         DE_UNREF(pRegions);
 887 }
 888
 889 VKAPI_ATTR void VKAPI_CALL cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 890 {
 891         DE_UNREF(commandBuffer);
 892         DE_UNREF(event);
 893         DE_UNREF(stageMask);
 894 }
 895
 896 VKAPI_ATTR void VKAPI_CALL cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 897 {
 898         DE_UNREF(commandBuffer);
 899         DE_UNREF(event);
 900         DE_UNREF(stageMask);
 901 }
 902
 903 VKAPI_ATTR void VKAPI_CALL cmdWaitEvents (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
 904 {
 905         DE_UNREF(commandBuffer);
 906         DE_UNREF(eventCount);
 907         DE_UNREF(pEvents);
 908         DE_UNREF(srcStageMask);
 909         DE_UNREF(dstStageMask);
 910         DE_UNREF(memoryBarrierCount);
 911         DE_UNREF(pMemoryBarriers);
 912         DE_UNREF(bufferMemoryBarrierCount);
 913         DE_UNREF(pBufferMemoryBarriers);
 914         DE_UNREF(imageMemoryBarrierCount);
 915         DE_UNREF(pImageMemoryBarriers);
 916 }
 917
 918 VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
 919 {
 920         DE_UNREF(commandBuffer);
 921         DE_UNREF(srcStageMask);
 922         DE_UNREF(dstStageMask);
 923         DE_UNREF(dependencyFlags);
 924         DE_UNREF(memoryBarrierCount);
 925         DE_UNREF(pMemoryBarriers);
 926         DE_UNREF(bufferMemoryBarrierCount);
 927         DE_UNREF(pBufferMemoryBarriers);
 928         DE_UNREF(imageMemoryBarrierCount);
 929         DE_UNREF(pImageMemoryBarriers);
 930 }
 931
 932 VKAPI_ATTR void VKAPI_CALL cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags)
 933 {
 934         DE_UNREF(commandBuffer);
 935         DE_UNREF(queryPool);
 936         DE_UNREF(query);
 937         DE_UNREF(flags);
 938 }
 939
 940 VKAPI_ATTR void VKAPI_CALL cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query)
 941 {
 942         DE_UNREF(commandBuffer);
 943         DE_UNREF(queryPool);
 944         DE_UNREF(query);
 945 }
 946
 947 VKAPI_ATTR void VKAPI_CALL cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount)
 948 {
 949         DE_UNREF(commandBuffer);
 950         DE_UNREF(queryPool);
 951         DE_UNREF(firstQuery);
 952         DE_UNREF(queryCount);
 953 }
 954
 955 VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query)
 956 {
 957         DE_UNREF(commandBuffer);
 958         DE_UNREF(pipelineStage);
 959         DE_UNREF(queryPool);
 960         DE_UNREF(query);
 961 }
 962
 963 VKAPI_ATTR void VKAPI_CALL cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 964 {
 965         DE_UNREF(commandBuffer);
 966         DE_UNREF(queryPool);
 967         DE_UNREF(firstQuery);
 968         DE_UNREF(queryCount);
 969         DE_UNREF(dstBuffer);
 970         DE_UNREF(dstOffset);
 971         DE_UNREF(stride);
 972         DE_UNREF(flags);
 973 }
 974
 975 VKAPI_ATTR void VKAPI_CALL cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 offset, deUint32 size, const void* pValues)
 976 {
 977         DE_UNREF(commandBuffer);
 978         DE_UNREF(layout);
 979         DE_UNREF(stageFlags);
 980         DE_UNREF(offset);
 981         DE_UNREF(size);
 982         DE_UNREF(pValues);
 983 }
 984
 985 VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
 986 {
 987         DE_UNREF(commandBuffer);
 988         DE_UNREF(pRenderPassBegin);
 989         DE_UNREF(contents);
 990 }
 991
 992 VKAPI_ATTR void VKAPI_CALL cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents)
 993 {
 994         DE_UNREF(commandBuffer);
 995         DE_UNREF(contents);
 996 }
 997
 998 VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass (VkCommandBuffer commandBuffer)
 999 {
1000         DE_UNREF(commandBuffer);
1001 }
1002
1003 VKAPI_ATTR void VKAPI_CALL cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers)
1004 {
1005         DE_UNREF(commandBuffer);
1006         DE_UNREF(commandBufferCount);
1007         DE_UNREF(pCommandBuffers);
1008 }
1009
1010 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceVersion (deUint32* pApiVersion)
1011 {
1012         DE_UNREF(pApiVersion);
1013         return VK_SUCCESS;
1014 }
1015
1016 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory2 (VkDevice device, deUint32 bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
1017 {
1018         DE_UNREF(device);
1019         DE_UNREF(bindInfoCount);
1020         DE_UNREF(pBindInfos);
1021         return VK_SUCCESS;
1022 }
1023
1024 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory2 (VkDevice device, deUint32 bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
1025 {
1026         DE_UNREF(device);
1027         DE_UNREF(bindInfoCount);
1028         DE_UNREF(pBindInfos);
1029         return VK_SUCCESS;
1030 }
1031
1032 VKAPI_ATTR void VKAPI_CALL getDeviceGroupPeerMemoryFeatures (VkDevice device, deUint32 heapIndex, deUint32 localDeviceIndex, deUint32 remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
1033 {
1034         DE_UNREF(device);
1035         DE_UNREF(heapIndex);
1036         DE_UNREF(localDeviceIndex);
1037         DE_UNREF(remoteDeviceIndex);
1038         DE_UNREF(pPeerMemoryFeatures);
1039 }
1040
1041 VKAPI_ATTR void VKAPI_CALL cmdSetDeviceMask (VkCommandBuffer commandBuffer, deUint32 deviceMask)
1042 {
1043         DE_UNREF(commandBuffer);
1044         DE_UNREF(deviceMask);
1045 }
1046
1047 VKAPI_ATTR void VKAPI_CALL cmdDispatchBase (VkCommandBuffer commandBuffer, deUint32 baseGroupX, deUint32 baseGroupY, deUint32 baseGroupZ, deUint32 groupCountX, deUint32 groupCountY, deUint32 groupCountZ)
1048 {
1049         DE_UNREF(commandBuffer);
1050         DE_UNREF(baseGroupX);
1051         DE_UNREF(baseGroupY);
1052         DE_UNREF(baseGroupZ);
1053         DE_UNREF(groupCountX);
1054         DE_UNREF(groupCountY);
1055         DE_UNREF(groupCountZ);
1056 }
1057
1058 VKAPI_ATTR VkResult VKAPI_CALL enumeratePhysicalDeviceGroups (VkInstance instance, deUint32* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
1059 {
1060         DE_UNREF(instance);
1061         DE_UNREF(pPhysicalDeviceGroupCount);
1062         DE_UNREF(pPhysicalDeviceGroupProperties);
1063         return VK_SUCCESS;
1064 }
1065
1066 VKAPI_ATTR void VKAPI_CALL getImageMemoryRequirements2 (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1067 {
1068         DE_UNREF(device);
1069         DE_UNREF(pInfo);
1070         DE_UNREF(pMemoryRequirements);
1071 }
1072
1073 VKAPI_ATTR void VKAPI_CALL getBufferMemoryRequirements2 (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
1074 {
1075         DE_UNREF(device);
1076         DE_UNREF(pInfo);
1077         DE_UNREF(pMemoryRequirements);
1078 }
1079
1080 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements2 (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
1081 {
1082         DE_UNREF(device);
1083         DE_UNREF(pInfo);
1084         DE_UNREF(pSparseMemoryRequirementCount);
1085         DE_UNREF(pSparseMemoryRequirements);
1086 }
1087
1088 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
1089 {
1090         DE_UNREF(physicalDevice);
1091         DE_UNREF(pFeatures);
1092 }
1093
1094 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
1095 {
1096         DE_UNREF(physicalDevice);
1097         DE_UNREF(pProperties);
1098 }
1099
1100 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFormatProperties2 (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
1101 {
1102         DE_UNREF(physicalDevice);
1103         DE_UNREF(format);
1104         DE_UNREF(pFormatProperties);
1105 }
1106
1107 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
1108 {
1109         DE_UNREF(physicalDevice);
1110         DE_UNREF(pImageFormatInfo);
1111         DE_UNREF(pImageFormatProperties);
1112         return VK_SUCCESS;
1113 }
1114
1115 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyProperties2 (VkPhysicalDevice physicalDevice, deUint32* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
1116 {
1117         DE_UNREF(physicalDevice);
1118         DE_UNREF(pQueueFamilyPropertyCount);
1119         DE_UNREF(pQueueFamilyProperties);
1120 }
1121
1122 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMemoryProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
1123 {
1124         DE_UNREF(physicalDevice);
1125         DE_UNREF(pMemoryProperties);
1126 }
1127
1128 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, deUint32* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
1129 {
1130         DE_UNREF(physicalDevice);
1131         DE_UNREF(pFormatInfo);
1132         DE_UNREF(pPropertyCount);
1133         DE_UNREF(pProperties);
1134 }
1135
1136 VKAPI_ATTR void VKAPI_CALL trimCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
1137 {
1138         DE_UNREF(device);
1139         DE_UNREF(commandPool);
1140         DE_UNREF(flags);
1141 }
1142
1143 VKAPI_ATTR void VKAPI_CALL getDeviceQueue2 (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
1144 {
1145         DE_UNREF(device);
1146         DE_UNREF(pQueueInfo);
1147         DE_UNREF(pQueue);
1148 }
1149
1150 VKAPI_ATTR void VKAPI_CALL updateDescriptorSetWithTemplate (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
1151 {
1152         DE_UNREF(device);
1153         DE_UNREF(descriptorSet);
1154         DE_UNREF(descriptorUpdateTemplate);
1155         DE_UNREF(pData);
1156 }
1157
1158 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalBufferProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
1159 {
1160         DE_UNREF(physicalDevice);
1161         DE_UNREF(pExternalBufferInfo);
1162         DE_UNREF(pExternalBufferProperties);
1163 }
1164
1165 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalFenceProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
1166 {
1167         DE_UNREF(physicalDevice);
1168         DE_UNREF(pExternalFenceInfo);
1169         DE_UNREF(pExternalFenceProperties);
1170 }
1171
1172 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalSemaphoreProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
1173 {
1174         DE_UNREF(physicalDevice);
1175         DE_UNREF(pExternalSemaphoreInfo);
1176         DE_UNREF(pExternalSemaphoreProperties);
1177 }
1178
1179 VKAPI_ATTR void VKAPI_CALL getDescriptorSetLayoutSupport (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
1180 {
1181         DE_UNREF(device);
1182         DE_UNREF(pCreateInfo);
1183         DE_UNREF(pSupport);
1184 }
1185
1186 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported)
1187 {
1188         DE_UNREF(physicalDevice);
1189         DE_UNREF(queueFamilyIndex);
1190         DE_UNREF(surface);
1191         DE_UNREF(pSupported);
1192         return VK_SUCCESS;
1193 }
1194
1195 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
1196 {
1197         DE_UNREF(physicalDevice);
1198         DE_UNREF(surface);
1199         DE_UNREF(pSurfaceCapabilities);
1200         return VK_SUCCESS;
1201 }
1202
1203 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormatsKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, deUint32* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats)
1204 {
1205         DE_UNREF(physicalDevice);
1206         DE_UNREF(surface);
1207         DE_UNREF(pSurfaceFormatCount);
1208         DE_UNREF(pSurfaceFormats);
1209         return VK_SUCCESS;
1210 }
1211
1212 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, deUint32* pPresentModeCount, VkPresentModeKHR* pPresentModes)
1213 {
1214         DE_UNREF(physicalDevice);
1215         DE_UNREF(surface);
1216         DE_UNREF(pPresentModeCount);
1217         DE_UNREF(pPresentModes);
1218         return VK_SUCCESS;
1219 }
1220
1221 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainImagesKHR (VkDevice device, VkSwapchainKHR swapchain, deUint32* pSwapchainImageCount, VkImage* pSwapchainImages)
1222 {
1223         DE_UNREF(device);
1224         DE_UNREF(swapchain);
1225         DE_UNREF(pSwapchainImageCount);
1226         DE_UNREF(pSwapchainImages);
1227         return VK_SUCCESS;
1228 }
1229
1230 VKAPI_ATTR VkResult VKAPI_CALL acquireNextImageKHR (VkDevice device, VkSwapchainKHR swapchain, deUint64 timeout, VkSemaphore semaphore, VkFence fence, deUint32* pImageIndex)
1231 {
1232         DE_UNREF(device);
1233         DE_UNREF(swapchain);
1234         DE_UNREF(timeout);
1235         DE_UNREF(semaphore);
1236         DE_UNREF(fence);
1237         DE_UNREF(pImageIndex);
1238         return VK_SUCCESS;
1239 }
1240
1241 VKAPI_ATTR VkResult VKAPI_CALL queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
1242 {
1243         DE_UNREF(queue);
1244         DE_UNREF(pPresentInfo);
1245         return VK_SUCCESS;
1246 }
1247
1248 VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupPresentCapabilitiesKHR (VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
1249 {
1250         DE_UNREF(device);
1251         DE_UNREF(pDeviceGroupPresentCapabilities);
1252         return VK_SUCCESS;
1253 }
1254
1255 VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupSurfacePresentModesKHR (VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes)
1256 {
1257         DE_UNREF(device);
1258         DE_UNREF(surface);
1259         DE_UNREF(pModes);
1260         return VK_SUCCESS;
1261 }
1262
1263 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDevicePresentRectanglesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, deUint32* pRectCount, VkRect2D* pRects)
1264 {
1265         DE_UNREF(physicalDevice);
1266         DE_UNREF(surface);
1267         DE_UNREF(pRectCount);
1268         DE_UNREF(pRects);
1269         return VK_SUCCESS;
1270 }
1271
1272 VKAPI_ATTR VkResult VKAPI_CALL acquireNextImage2KHR (VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, deUint32* pImageIndex)
1273 {
1274         DE_UNREF(device);
1275         DE_UNREF(pAcquireInfo);
1276         DE_UNREF(pImageIndex);
1277         return VK_SUCCESS;
1278 }
1279
1280 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPropertiesKHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPropertiesKHR* pProperties)
1281 {
1282         DE_UNREF(physicalDevice);
1283         DE_UNREF(pPropertyCount);
1284         DE_UNREF(pProperties);
1285         return VK_SUCCESS;
1286 }
1287
1288 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlanePropertiesKHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties)
1289 {
1290         DE_UNREF(physicalDevice);
1291         DE_UNREF(pPropertyCount);
1292         DE_UNREF(pProperties);
1293         return VK_SUCCESS;
1294 }
1295
1296 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneSupportedDisplaysKHR (VkPhysicalDevice physicalDevice, deUint32 planeIndex, deUint32* pDisplayCount, VkDisplayKHR* pDisplays)
1297 {
1298         DE_UNREF(physicalDevice);
1299         DE_UNREF(planeIndex);
1300         DE_UNREF(pDisplayCount);
1301         DE_UNREF(pDisplays);
1302         return VK_SUCCESS;
1303 }
1304
1305 VKAPI_ATTR VkResult VKAPI_CALL getDisplayModePropertiesKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, deUint32* pPropertyCount, VkDisplayModePropertiesKHR* pProperties)
1306 {
1307         DE_UNREF(physicalDevice);
1308         DE_UNREF(display);
1309         DE_UNREF(pPropertyCount);
1310         DE_UNREF(pProperties);
1311         return VK_SUCCESS;
1312 }
1313
1314 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, deUint32 planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities)
1315 {
1316         DE_UNREF(physicalDevice);
1317         DE_UNREF(mode);
1318         DE_UNREF(planeIndex);
1319         DE_UNREF(pCapabilities);
1320         return VK_SUCCESS;
1321 }
1322
1323 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXlibPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::XlibDisplayPtr dpy, pt::XlibVisualID visualID)
1324 {
1325         DE_UNREF(physicalDevice);
1326         DE_UNREF(queueFamilyIndex);
1327         DE_UNREF(dpy);
1328         DE_UNREF(visualID);
1329         return VK_SUCCESS;
1330 }
1331
1332 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXcbPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::XcbConnectionPtr connection, pt::XcbVisualid visual_id)
1333 {
1334         DE_UNREF(physicalDevice);
1335         DE_UNREF(queueFamilyIndex);
1336         DE_UNREF(connection);
1337         DE_UNREF(visual_id);
1338         return VK_SUCCESS;
1339 }
1340
1341 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWaylandPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::WaylandDisplayPtr display)
1342 {
1343         DE_UNREF(physicalDevice);
1344         DE_UNREF(queueFamilyIndex);
1345         DE_UNREF(display);
1346         return VK_SUCCESS;
1347 }
1348
1349 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceMirPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::MirConnectionPtr connection)
1350 {
1351         DE_UNREF(physicalDevice);
1352         DE_UNREF(queueFamilyIndex);
1353         DE_UNREF(connection);
1354         return VK_SUCCESS;
1355 }
1356
1357 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex)
1358 {
1359         DE_UNREF(physicalDevice);
1360         DE_UNREF(queueFamilyIndex);
1361         return VK_SUCCESS;
1362 }
1363
1364 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
1365 {
1366         DE_UNREF(device);
1367         DE_UNREF(pGetWin32HandleInfo);
1368         DE_UNREF(pHandle);
1369         return VK_SUCCESS;
1370 }
1371
1372 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
1373 {
1374         DE_UNREF(device);
1375         DE_UNREF(handleType);
1376         DE_UNREF(handle);
1377         DE_UNREF(pMemoryWin32HandleProperties);
1378         return VK_SUCCESS;
1379 }
1380
1381 VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd)
1382 {
1383         DE_UNREF(device);
1384         DE_UNREF(pGetFdInfo);
1385         DE_UNREF(pFd);
1386         return VK_SUCCESS;
1387 }
1388
1389 VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdPropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties)
1390 {
1391         DE_UNREF(device);
1392         DE_UNREF(handleType);
1393         DE_UNREF(fd);
1394         DE_UNREF(pMemoryFdProperties);
1395         return VK_SUCCESS;
1396 }
1397
1398 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreWin32HandleKHR (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
1399 {
1400         DE_UNREF(device);
1401         DE_UNREF(pImportSemaphoreWin32HandleInfo);
1402         return VK_SUCCESS;
1403 }
1404
1405 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreWin32HandleKHR (VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
1406 {
1407         DE_UNREF(device);
1408         DE_UNREF(pGetWin32HandleInfo);
1409         DE_UNREF(pHandle);
1410         return VK_SUCCESS;
1411 }
1412
1413 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreFdKHR (VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
1414 {
1415         DE_UNREF(device);
1416         DE_UNREF(pImportSemaphoreFdInfo);
1417         return VK_SUCCESS;
1418 }
1419
1420 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd)
1421 {
1422         DE_UNREF(device);
1423         DE_UNREF(pGetFdInfo);
1424         DE_UNREF(pFd);
1425         return VK_SUCCESS;
1426 }
1427
1428 VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
1429 {
1430         DE_UNREF(commandBuffer);
1431         DE_UNREF(pipelineBindPoint);
1432         DE_UNREF(layout);
1433         DE_UNREF(set);
1434         DE_UNREF(descriptorWriteCount);
1435         DE_UNREF(pDescriptorWrites);
1436 }
1437
1438 VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData)
1439 {
1440         DE_UNREF(commandBuffer);
1441         DE_UNREF(descriptorUpdateTemplate);
1442         DE_UNREF(layout);
1443         DE_UNREF(set);
1444         DE_UNREF(pData);
1445 }
1446
1447 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain)
1448 {
1449         DE_UNREF(device);
1450         DE_UNREF(swapchain);
1451         return VK_SUCCESS;
1452 }
1453
1454 VKAPI_ATTR VkResult VKAPI_CALL importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
1455 {
1456         DE_UNREF(device);
1457         DE_UNREF(pImportFenceWin32HandleInfo);
1458         return VK_SUCCESS;
1459 }
1460
1461 VKAPI_ATTR VkResult VKAPI_CALL getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
1462 {
1463         DE_UNREF(device);
1464         DE_UNREF(pGetWin32HandleInfo);
1465         DE_UNREF(pHandle);
1466         return VK_SUCCESS;
1467 }
1468
1469 VKAPI_ATTR VkResult VKAPI_CALL importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
1470 {
1471         DE_UNREF(device);
1472         DE_UNREF(pImportFenceFdInfo);
1473         return VK_SUCCESS;
1474 }
1475
1476 VKAPI_ATTR VkResult VKAPI_CALL getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd)
1477 {
1478         DE_UNREF(device);
1479         DE_UNREF(pGetFdInfo);
1480         DE_UNREF(pFd);
1481         return VK_SUCCESS;
1482 }
1483
1484 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
1485 {
1486         DE_UNREF(physicalDevice);
1487         DE_UNREF(pSurfaceInfo);
1488         DE_UNREF(pSurfaceCapabilities);
1489         return VK_SUCCESS;
1490 }
1491
1492 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats)
1493 {
1494         DE_UNREF(physicalDevice);
1495         DE_UNREF(pSurfaceInfo);
1496         DE_UNREF(pSurfaceFormatCount);
1497         DE_UNREF(pSurfaceFormats);
1498         return VK_SUCCESS;
1499 }
1500
1501 VKAPI_ATTR void VKAPI_CALL debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage)
1502 {
1503         DE_UNREF(instance);
1504         DE_UNREF(flags);
1505         DE_UNREF(objectType);
1506         DE_UNREF(object);
1507         DE_UNREF(location);
1508         DE_UNREF(messageCode);
1509         DE_UNREF(pLayerPrefix);
1510         DE_UNREF(pMessage);
1511 }
1512
1513 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
1514 {
1515         DE_UNREF(device);
1516         DE_UNREF(pTagInfo);
1517         return VK_SUCCESS;
1518 }
1519
1520 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
1521 {
1522         DE_UNREF(device);
1523         DE_UNREF(pNameInfo);
1524         return VK_SUCCESS;
1525 }
1526
1527 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
1528 {
1529         DE_UNREF(commandBuffer);
1530         DE_UNREF(pMarkerInfo);
1531 }
1532
1533 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer)
1534 {
1535         DE_UNREF(commandBuffer);
1536 }
1537
1538 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
1539 {
1540         DE_UNREF(commandBuffer);
1541         DE_UNREF(pMarkerInfo);
1542 }
1543
1544 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride)
1545 {
1546         DE_UNREF(commandBuffer);
1547         DE_UNREF(buffer);
1548         DE_UNREF(offset);
1549         DE_UNREF(countBuffer);
1550         DE_UNREF(countBufferOffset);
1551         DE_UNREF(maxDrawCount);
1552         DE_UNREF(stride);
1553 }
1554
1555 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride)
1556 {
1557         DE_UNREF(commandBuffer);
1558         DE_UNREF(buffer);
1559         DE_UNREF(offset);
1560         DE_UNREF(countBuffer);
1561         DE_UNREF(countBufferOffset);
1562         DE_UNREF(maxDrawCount);
1563         DE_UNREF(stride);
1564 }
1565
1566 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
1567 {
1568         DE_UNREF(physicalDevice);
1569         DE_UNREF(format);
1570         DE_UNREF(type);
1571         DE_UNREF(tiling);
1572         DE_UNREF(usage);
1573         DE_UNREF(flags);
1574         DE_UNREF(externalHandleType);
1575         DE_UNREF(pExternalImageFormatProperties);
1576         return VK_SUCCESS;
1577 }
1578
1579 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle)
1580 {
1581         DE_UNREF(device);
1582         DE_UNREF(memory);
1583         DE_UNREF(handleType);
1584         DE_UNREF(pHandle);
1585         return VK_SUCCESS;
1586 }
1587
1588 VKAPI_ATTR void VKAPI_CALL cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
1589 {
1590         DE_UNREF(commandBuffer);
1591         DE_UNREF(pProcessCommandsInfo);
1592 }
1593
1594 VKAPI_ATTR void VKAPI_CALL cmdReserveSpaceForCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
1595 {
1596         DE_UNREF(commandBuffer);
1597         DE_UNREF(pReserveSpaceInfo);
1598 }
1599
1600 VKAPI_ATTR VkResult VKAPI_CALL registerObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const deUint32* pObjectIndices)
1601 {
1602         DE_UNREF(device);
1603         DE_UNREF(objectTable);
1604         DE_UNREF(objectCount);
1605         DE_UNREF(ppObjectTableEntries);
1606         DE_UNREF(pObjectIndices);
1607         return VK_SUCCESS;
1608 }
1609
1610 VKAPI_ATTR VkResult VKAPI_CALL unregisterObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const deUint32* pObjectIndices)
1611 {
1612         DE_UNREF(device);
1613         DE_UNREF(objectTable);
1614         DE_UNREF(objectCount);
1615         DE_UNREF(pObjectEntryTypes);
1616         DE_UNREF(pObjectIndices);
1617         return VK_SUCCESS;
1618 }
1619
1620 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceGeneratedCommandsPropertiesNVX (VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits)
1621 {
1622         DE_UNREF(physicalDevice);
1623         DE_UNREF(pFeatures);
1624         DE_UNREF(pLimits);
1625 }
1626
1627 VKAPI_ATTR void VKAPI_CALL cmdSetViewportWScalingNV (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewportWScalingNV* pViewportWScalings)
1628 {
1629         DE_UNREF(commandBuffer);
1630         DE_UNREF(firstViewport);
1631         DE_UNREF(viewportCount);
1632         DE_UNREF(pViewportWScalings);
1633 }
1634
1635 VKAPI_ATTR VkResult VKAPI_CALL releaseDisplayEXT (VkPhysicalDevice physicalDevice, VkDisplayKHR display)
1636 {
1637         DE_UNREF(physicalDevice);
1638         DE_UNREF(display);
1639         return VK_SUCCESS;
1640 }
1641
1642 VKAPI_ATTR VkResult VKAPI_CALL acquireXlibDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, VkDisplayKHR display)
1643 {
1644         DE_UNREF(physicalDevice);
1645         DE_UNREF(dpy);
1646         DE_UNREF(display);
1647         return VK_SUCCESS;
1648 }
1649
1650 VKAPI_ATTR VkResult VKAPI_CALL getRandROutputDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, pt::RROutput rrOutput, VkDisplayKHR* pDisplay)
1651 {
1652         DE_UNREF(physicalDevice);
1653         DE_UNREF(dpy);
1654         DE_UNREF(rrOutput);
1655         DE_UNREF(pDisplay);
1656         return VK_SUCCESS;
1657 }
1658
1659 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2EXT (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
1660 {
1661         DE_UNREF(physicalDevice);
1662         DE_UNREF(surface);
1663         DE_UNREF(pSurfaceCapabilities);
1664         return VK_SUCCESS;
1665 }
1666
1667 VKAPI_ATTR VkResult VKAPI_CALL displayPowerControlEXT (VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
1668 {
1669         DE_UNREF(device);
1670         DE_UNREF(display);
1671         DE_UNREF(pDisplayPowerInfo);
1672         return VK_SUCCESS;
1673 }
1674
1675 VKAPI_ATTR VkResult VKAPI_CALL registerDeviceEventEXT (VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
1676 {
1677         DE_UNREF(device);
1678         DE_UNREF(pDeviceEventInfo);
1679         DE_UNREF(pAllocator);
1680         DE_UNREF(pFence);
1681         return VK_SUCCESS;
1682 }
1683
1684 VKAPI_ATTR VkResult VKAPI_CALL registerDisplayEventEXT (VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
1685 {
1686         DE_UNREF(device);
1687         DE_UNREF(display);
1688         DE_UNREF(pDisplayEventInfo);
1689         DE_UNREF(pAllocator);
1690         DE_UNREF(pFence);
1691         return VK_SUCCESS;
1692 }
1693
1694 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainCounterEXT (VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, deUint64* pCounterValue)
1695 {
1696         DE_UNREF(device);
1697         DE_UNREF(swapchain);
1698         DE_UNREF(counter);
1699         DE_UNREF(pCounterValue);
1700         return VK_SUCCESS;
1701 }
1702
1703 VKAPI_ATTR VkResult VKAPI_CALL getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
1704 {
1705         DE_UNREF(device);
1706         DE_UNREF(swapchain);
1707         DE_UNREF(pDisplayTimingProperties);
1708         return VK_SUCCESS;
1709 }
1710
1711 VKAPI_ATTR VkResult VKAPI_CALL getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, deUint32* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings)
1712 {
1713         DE_UNREF(device);
1714         DE_UNREF(swapchain);
1715         DE_UNREF(pPresentationTimingCount);
1716         DE_UNREF(pPresentationTimings);
1717         return VK_SUCCESS;
1718 }
1719
1720 VKAPI_ATTR void VKAPI_CALL cmdSetDiscardRectangleEXT (VkCommandBuffer commandBuffer, deUint32 firstDiscardRectangle, deUint32 discardRectangleCount, const VkRect2D* pDiscardRectangles)
1721 {
1722         DE_UNREF(commandBuffer);
1723         DE_UNREF(firstDiscardRectangle);
1724         DE_UNREF(discardRectangleCount);
1725         DE_UNREF(pDiscardRectangles);
1726 }
1727
1728 VKAPI_ATTR void VKAPI_CALL setHdrMetadataEXT (VkDevice device, deUint32 swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata)
1729 {
1730         DE_UNREF(device);
1731         DE_UNREF(swapchainCount);
1732         DE_UNREF(pSwapchains);
1733         DE_UNREF(pMetadata);
1734 }
1735
1736 VKAPI_ATTR void VKAPI_CALL cmdSetSampleLocationsEXT (VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
1737 {
1738         DE_UNREF(commandBuffer);
1739         DE_UNREF(pSampleLocationsInfo);
1740 }
1741
1742 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMultisamplePropertiesEXT (VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties)
1743 {
1744         DE_UNREF(physicalDevice);
1745         DE_UNREF(samples);
1746         DE_UNREF(pMultisampleProperties);
1747 }
1748
1749 VKAPI_ATTR VkResult VKAPI_CALL mergeValidationCachesEXT (VkDevice device, VkValidationCacheEXT dstCache, deUint32 srcCacheCount, const VkValidationCacheEXT* pSrcCaches)
1750 {
1751         DE_UNREF(device);
1752         DE_UNREF(dstCache);
1753         DE_UNREF(srcCacheCount);
1754         DE_UNREF(pSrcCaches);
1755         return VK_SUCCESS;
1756 }
1757
1758 VKAPI_ATTR VkResult VKAPI_CALL getValidationCacheDataEXT (VkDevice device, VkValidationCacheEXT validationCache, deUintptr* pDataSize, void* pData)
1759 {
1760         DE_UNREF(device);
1761         DE_UNREF(validationCache);
1762         DE_UNREF(pDataSize);
1763         DE_UNREF(pData);
1764         return VK_SUCCESS;
1765 }
1766
1767 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceAndroidHardwareBufferUsageANDROID (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceAndroidHardwareBufferInfoANDROID* pInfo, VkAndroidHardwareBufferUsageANDROID* pUsage)
1768 {
1769         DE_UNREF(physicalDevice);
1770         DE_UNREF(pInfo);
1771         DE_UNREF(pUsage);
1772 }
1773
1774 VKAPI_ATTR VkResult VKAPI_CALL getMemoryAndroidHardwareBufferPropertiesANDROID (VkDevice device, const pt::AndroidHardwareBufferPtr buffer, VkMemoryAndroidHardwareBufferPropertiesANDROID* pProperties)
1775 {
1776         DE_UNREF(device);
1777         DE_UNREF(buffer);
1778         DE_UNREF(pProperties);
1779         return VK_SUCCESS;
1780 }
1781
1782 static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
1783 {
1784         VK_NULL_FUNC_ENTRY(vkCreateInstance,                                            createInstance),
1785         VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr,                                       getInstanceProcAddr),
1786         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceExtensionProperties,      enumerateInstanceExtensionProperties),
1787         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceLayerProperties,          enumerateInstanceLayerProperties),
1788         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceVersion,                          enumerateInstanceVersion),
1789 };
1790
1791 static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
1792 {
1793         VK_NULL_FUNC_ENTRY(vkDestroyInstance,                                                                           destroyInstance),
1794         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDevices,                                                          enumeratePhysicalDevices),
1795         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures,                                                         getPhysicalDeviceFeatures),
1796         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties,                                         getPhysicalDeviceFormatProperties),
1797         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties,                            getPhysicalDeviceImageFormatProperties),
1798         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties,                                                       getPhysicalDeviceProperties),
1799         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties,                            getPhysicalDeviceQueueFamilyProperties),
1800         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties,                                         getPhysicalDeviceMemoryProperties),
1801         VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr,                                                                         getDeviceProcAddr),
1802         VK_NULL_FUNC_ENTRY(vkCreateDevice,                                                                                      createDevice),
1803         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceExtensionProperties,                                        enumerateDeviceExtensionProperties),
1804         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceLayerProperties,                                            enumerateDeviceLayerProperties),
1805         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties,                      getPhysicalDeviceSparseImageFormatProperties),
1806         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceGroups,                                                     enumeratePhysicalDeviceGroups),
1807         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures2,                                                        getPhysicalDeviceFeatures2),
1808         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties2,                                                      getPhysicalDeviceProperties2),
1809         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties2,                                        getPhysicalDeviceFormatProperties2),
1810         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties2,                           getPhysicalDeviceImageFormatProperties2),
1811         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2,                           getPhysicalDeviceQueueFamilyProperties2),
1812         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2,                                        getPhysicalDeviceMemoryProperties2),
1813         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2,                     getPhysicalDeviceSparseImageFormatProperties2),
1814         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferProperties,                         getPhysicalDeviceExternalBufferProperties),
1815         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFenceProperties,                          getPhysicalDeviceExternalFenceProperties),
1816         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphoreProperties,                      getPhysicalDeviceExternalSemaphoreProperties),
1817         VK_NULL_FUNC_ENTRY(vkDestroySurfaceKHR,                                                                         destroySurfaceKHR),
1818         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceSupportKHR,                                        getPhysicalDeviceSurfaceSupportKHR),
1819         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilitiesKHR,                           getPhysicalDeviceSurfaceCapabilitiesKHR),
1820         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormatsKHR,                                        getPhysicalDeviceSurfaceFormatsKHR),
1821         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModesKHR,                           getPhysicalDeviceSurfacePresentModesKHR),
1822         VK_NULL_FUNC_ENTRY(vkGetPhysicalDevicePresentRectanglesKHR,                                     getPhysicalDevicePresentRectanglesKHR),
1823         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPropertiesKHR,                                     getPhysicalDeviceDisplayPropertiesKHR),
1824         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlanePropertiesKHR,                        getPhysicalDeviceDisplayPlanePropertiesKHR),
1825         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneSupportedDisplaysKHR,                                       getDisplayPlaneSupportedDisplaysKHR),
1826         VK_NULL_FUNC_ENTRY(vkGetDisplayModePropertiesKHR,                                                       getDisplayModePropertiesKHR),
1827         VK_NULL_FUNC_ENTRY(vkCreateDisplayModeKHR,                                                                      createDisplayModeKHR),
1828         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilitiesKHR,                                            getDisplayPlaneCapabilitiesKHR),
1829         VK_NULL_FUNC_ENTRY(vkCreateDisplayPlaneSurfaceKHR,                                                      createDisplayPlaneSurfaceKHR),
1830         VK_NULL_FUNC_ENTRY(vkCreateXlibSurfaceKHR,                                                                      createXlibSurfaceKHR),
1831         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXlibPresentationSupportKHR,                       getPhysicalDeviceXlibPresentationSupportKHR),
1832         VK_NULL_FUNC_ENTRY(vkCreateXcbSurfaceKHR,                                                                       createXcbSurfaceKHR),
1833         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXcbPresentationSupportKHR,                        getPhysicalDeviceXcbPresentationSupportKHR),
1834         VK_NULL_FUNC_ENTRY(vkCreateWaylandSurfaceKHR,                                                           createWaylandSurfaceKHR),
1835         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWaylandPresentationSupportKHR,            getPhysicalDeviceWaylandPresentationSupportKHR),
1836         VK_NULL_FUNC_ENTRY(vkCreateMirSurfaceKHR,                                                                       createMirSurfaceKHR),
1837         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMirPresentationSupportKHR,                        getPhysicalDeviceMirPresentationSupportKHR),
1838         VK_NULL_FUNC_ENTRY(vkCreateAndroidSurfaceKHR,                                                           createAndroidSurfaceKHR),
1839         VK_NULL_FUNC_ENTRY(vkCreateWin32SurfaceKHR,                                                                     createWin32SurfaceKHR),
1840         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWin32PresentationSupportKHR,                      getPhysicalDeviceWin32PresentationSupportKHR),
1841         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures2KHR,                                                     getPhysicalDeviceFeatures2),
1842         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties2KHR,                                     getPhysicalDeviceFormatProperties2),
1843         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties2KHR,                        getPhysicalDeviceImageFormatProperties2),
1844         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2KHR,                                     getPhysicalDeviceMemoryProperties2),
1845         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties2KHR,                                           getPhysicalDeviceProperties2),
1846         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2KHR,                        getPhysicalDeviceQueueFamilyProperties2),
1847         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2KHR,          getPhysicalDeviceSparseImageFormatProperties2),
1848         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceGroupsKHR,                                          enumeratePhysicalDeviceGroups),
1849         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferPropertiesKHR,                      getPhysicalDeviceExternalBufferProperties),
1850         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,           getPhysicalDeviceExternalSemaphoreProperties),
1851         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFencePropertiesKHR,                       getPhysicalDeviceExternalFenceProperties),
1852         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2KHR,                          getPhysicalDeviceSurfaceCapabilities2KHR),
1853         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormats2KHR,                                       getPhysicalDeviceSurfaceFormats2KHR),
1854         VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT,                                                      createDebugReportCallbackEXT),
1855         VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT,                                                     destroyDebugReportCallbackEXT),
1856         VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT,                                                                     debugReportMessageEXT),
1857         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalImageFormatPropertiesNV,          getPhysicalDeviceExternalImageFormatPropertiesNV),
1858         VK_NULL_FUNC_ENTRY(vkCreateViSurfaceNN,                                                                         createViSurfaceNN),
1859         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX,           getPhysicalDeviceGeneratedCommandsPropertiesNVX),
1860         VK_NULL_FUNC_ENTRY(vkReleaseDisplayEXT,                                                                         releaseDisplayEXT),
1861         VK_NULL_FUNC_ENTRY(vkAcquireXlibDisplayEXT,                                                                     acquireXlibDisplayEXT),
1862         VK_NULL_FUNC_ENTRY(vkGetRandROutputDisplayEXT,                                                          getRandROutputDisplayEXT),
1863         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2EXT,                          getPhysicalDeviceSurfaceCapabilities2EXT),
1864         VK_NULL_FUNC_ENTRY(vkCreateIOSSurfaceMVK,                                                                       createIOSSurfaceMVK),
1865         VK_NULL_FUNC_ENTRY(vkCreateMacOSSurfaceMVK,                                                                     createMacOSSurfaceMVK),
1866         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMultisamplePropertiesEXT,                         getPhysicalDeviceMultisamplePropertiesEXT),
1867         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceAndroidHardwareBufferUsageANDROID,        getPhysicalDeviceAndroidHardwareBufferUsageANDROID),
1868 };
1869
1870 static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
1871 {
1872         VK_NULL_FUNC_ENTRY(vkDestroyDevice,                                                                             destroyDevice),
1873         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue,                                                                    getDeviceQueue),
1874         VK_NULL_FUNC_ENTRY(vkQueueSubmit,                                                                               queueSubmit),
1875         VK_NULL_FUNC_ENTRY(vkQueueWaitIdle,                                                                             queueWaitIdle),
1876         VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle,                                                                    deviceWaitIdle),
1877         VK_NULL_FUNC_ENTRY(vkAllocateMemory,                                                                    allocateMemory),
1878         VK_NULL_FUNC_ENTRY(vkFreeMemory,                                                                                freeMemory),
1879         VK_NULL_FUNC_ENTRY(vkMapMemory,                                                                                 mapMemory),
1880         VK_NULL_FUNC_ENTRY(vkUnmapMemory,                                                                               unmapMemory),
1881         VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges,                                                   flushMappedMemoryRanges),
1882         VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges,                                              invalidateMappedMemoryRanges),
1883         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment,                                                 getDeviceMemoryCommitment),
1884         VK_NULL_FUNC_ENTRY(vkBindBufferMemory,                                                                  bindBufferMemory),
1885         VK_NULL_FUNC_ENTRY(vkBindImageMemory,                                                                   bindImageMemory),
1886         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements,                                               getBufferMemoryRequirements),
1887         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements,                                                getImageMemoryRequirements),
1888         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements,                                  getImageSparseMemoryRequirements),
1889         VK_NULL_FUNC_ENTRY(vkQueueBindSparse,                                                                   queueBindSparse),
1890         VK_NULL_FUNC_ENTRY(vkCreateFence,                                                                               createFence),
1891         VK_NULL_FUNC_ENTRY(vkDestroyFence,                                                                              destroyFence),
1892         VK_NULL_FUNC_ENTRY(vkResetFences,                                                                               resetFences),
1893         VK_NULL_FUNC_ENTRY(vkGetFenceStatus,                                                                    getFenceStatus),
1894         VK_NULL_FUNC_ENTRY(vkWaitForFences,                                                                             waitForFences),
1895         VK_NULL_FUNC_ENTRY(vkCreateSemaphore,                                                                   createSemaphore),
1896         VK_NULL_FUNC_ENTRY(vkDestroySemaphore,                                                                  destroySemaphore),
1897         VK_NULL_FUNC_ENTRY(vkCreateEvent,                                                                               createEvent),
1898         VK_NULL_FUNC_ENTRY(vkDestroyEvent,                                                                              destroyEvent),
1899         VK_NULL_FUNC_ENTRY(vkGetEventStatus,                                                                    getEventStatus),
1900         VK_NULL_FUNC_ENTRY(vkSetEvent,                                                                                  setEvent),
1901         VK_NULL_FUNC_ENTRY(vkResetEvent,                                                                                resetEvent),
1902         VK_NULL_FUNC_ENTRY(vkCreateQueryPool,                                                                   createQueryPool),
1903         VK_NULL_FUNC_ENTRY(vkDestroyQueryPool,                                                                  destroyQueryPool),
1904         VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults,                                                               getQueryPoolResults),
1905         VK_NULL_FUNC_ENTRY(vkCreateBuffer,                                                                              createBuffer),
1906         VK_NULL_FUNC_ENTRY(vkDestroyBuffer,                                                                             destroyBuffer),
1907         VK_NULL_FUNC_ENTRY(vkCreateBufferView,                                                                  createBufferView),
1908         VK_NULL_FUNC_ENTRY(vkDestroyBufferView,                                                                 destroyBufferView),
1909         VK_NULL_FUNC_ENTRY(vkCreateImage,                                                                               createImage),
1910         VK_NULL_FUNC_ENTRY(vkDestroyImage,                                                                              destroyImage),
1911         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout,                                                 getImageSubresourceLayout),
1912         VK_NULL_FUNC_ENTRY(vkCreateImageView,                                                                   createImageView),
1913         VK_NULL_FUNC_ENTRY(vkDestroyImageView,                                                                  destroyImageView),
1914         VK_NULL_FUNC_ENTRY(vkCreateShaderModule,                                                                createShaderModule),
1915         VK_NULL_FUNC_ENTRY(vkDestroyShaderModule,                                                               destroyShaderModule),
1916         VK_NULL_FUNC_ENTRY(vkCreatePipelineCache,                                                               createPipelineCache),
1917         VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache,                                                              destroyPipelineCache),
1918         VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData,                                                              getPipelineCacheData),
1919         VK_NULL_FUNC_ENTRY(vkMergePipelineCaches,                                                               mergePipelineCaches),
1920         VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines,                                                   createGraphicsPipelines),
1921         VK_NULL_FUNC_ENTRY(vkCreateComputePipelines,                                                    createComputePipelines),
1922         VK_NULL_FUNC_ENTRY(vkDestroyPipeline,                                                                   destroyPipeline),
1923         VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout,                                                              createPipelineLayout),
1924         VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout,                                                             destroyPipelineLayout),
1925         VK_NULL_FUNC_ENTRY(vkCreateSampler,                                                                             createSampler),
1926         VK_NULL_FUNC_ENTRY(vkDestroySampler,                                                                    destroySampler),
1927         VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout,                                                 createDescriptorSetLayout),
1928         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout,                                                destroyDescriptorSetLayout),
1929         VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool,                                                              createDescriptorPool),
1930         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool,                                                             destroyDescriptorPool),
1931         VK_NULL_FUNC_ENTRY(vkResetDescriptorPool,                                                               resetDescriptorPool),
1932         VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets,                                                    allocateDescriptorSets),
1933         VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets,                                                                freeDescriptorSets),
1934         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets,                                                              updateDescriptorSets),
1935         VK_NULL_FUNC_ENTRY(vkCreateFramebuffer,                                                                 createFramebuffer),
1936         VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer,                                                                destroyFramebuffer),
1937         VK_NULL_FUNC_ENTRY(vkCreateRenderPass,                                                                  createRenderPass),
1938         VK_NULL_FUNC_ENTRY(vkDestroyRenderPass,                                                                 destroyRenderPass),
1939         VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity,                                                  getRenderAreaGranularity),
1940         VK_NULL_FUNC_ENTRY(vkCreateCommandPool,                                                                 createCommandPool),
1941         VK_NULL_FUNC_ENTRY(vkDestroyCommandPool,                                                                destroyCommandPool),
1942         VK_NULL_FUNC_ENTRY(vkResetCommandPool,                                                                  resetCommandPool),
1943         VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers,                                                    allocateCommandBuffers),
1944         VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers,                                                                freeCommandBuffers),
1945         VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer,                                                                beginCommandBuffer),
1946         VK_NULL_FUNC_ENTRY(vkEndCommandBuffer,                                                                  endCommandBuffer),
1947         VK_NULL_FUNC_ENTRY(vkResetCommandBuffer,                                                                resetCommandBuffer),
1948         VK_NULL_FUNC_ENTRY(vkCmdBindPipeline,                                                                   cmdBindPipeline),
1949         VK_NULL_FUNC_ENTRY(vkCmdSetViewport,                                                                    cmdSetViewport),
1950         VK_NULL_FUNC_ENTRY(vkCmdSetScissor,                                                                             cmdSetScissor),
1951         VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth,                                                                   cmdSetLineWidth),
1952         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias,                                                                   cmdSetDepthBias),
1953         VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants,                                                              cmdSetBlendConstants),
1954         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds,                                                                 cmdSetDepthBounds),
1955         VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask,                                                  cmdSetStencilCompareMask),
1956         VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask,                                                    cmdSetStencilWriteMask),
1957         VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference,                                                    cmdSetStencilReference),
1958         VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets,                                                             cmdBindDescriptorSets),
1959         VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer,                                                                cmdBindIndexBuffer),
1960         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers,                                                              cmdBindVertexBuffers),
1961         VK_NULL_FUNC_ENTRY(vkCmdDraw,                                                                                   cmdDraw),
1962         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed,                                                                    cmdDrawIndexed),
1963         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect,                                                                   cmdDrawIndirect),
1964         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect,                                                    cmdDrawIndexedIndirect),
1965         VK_NULL_FUNC_ENTRY(vkCmdDispatch,                                                                               cmdDispatch),
1966         VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect,                                                               cmdDispatchIndirect),
1967         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer,                                                                             cmdCopyBuffer),
1968         VK_NULL_FUNC_ENTRY(vkCmdCopyImage,                                                                              cmdCopyImage),
1969         VK_NULL_FUNC_ENTRY(vkCmdBlitImage,                                                                              cmdBlitImage),
1970         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage,                                                              cmdCopyBufferToImage),
1971         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer,                                                              cmdCopyImageToBuffer),
1972         VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer,                                                                   cmdUpdateBuffer),
1973         VK_NULL_FUNC_ENTRY(vkCmdFillBuffer,                                                                             cmdFillBuffer),
1974         VK_NULL_FUNC_ENTRY(vkCmdClearColorImage,                                                                cmdClearColorImage),
1975         VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage,                                                 cmdClearDepthStencilImage),
1976         VK_NULL_FUNC_ENTRY(vkCmdClearAttachments,                                                               cmdClearAttachments),
1977         VK_NULL_FUNC_ENTRY(vkCmdResolveImage,                                                                   cmdResolveImage),
1978         VK_NULL_FUNC_ENTRY(vkCmdSetEvent,                                                                               cmdSetEvent),
1979         VK_NULL_FUNC_ENTRY(vkCmdResetEvent,                                                                             cmdResetEvent),
1980         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents,                                                                             cmdWaitEvents),
1981         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier,                                                                cmdPipelineBarrier),
1982         VK_NULL_FUNC_ENTRY(vkCmdBeginQuery,                                                                             cmdBeginQuery),
1983         VK_NULL_FUNC_ENTRY(vkCmdEndQuery,                                                                               cmdEndQuery),
1984         VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool,                                                                 cmdResetQueryPool),
1985         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp,                                                                 cmdWriteTimestamp),
1986         VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults,                                                   cmdCopyQueryPoolResults),
1987         VK_NULL_FUNC_ENTRY(vkCmdPushConstants,                                                                  cmdPushConstants),
1988         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass,                                                                cmdBeginRenderPass),
1989         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass,                                                                    cmdNextSubpass),
1990         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass,                                                                  cmdEndRenderPass),
1991         VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands,                                                                cmdExecuteCommands),
1992         VK_NULL_FUNC_ENTRY(vkBindBufferMemory2,                                                                 bindBufferMemory2),
1993         VK_NULL_FUNC_ENTRY(vkBindImageMemory2,                                                                  bindImageMemory2),
1994         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeatures,                                  getDeviceGroupPeerMemoryFeatures),
1995         VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMask,                                                                  cmdSetDeviceMask),
1996         VK_NULL_FUNC_ENTRY(vkCmdDispatchBase,                                                                   cmdDispatchBase),
1997         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2,                                               getImageMemoryRequirements2),
1998         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2,                                              getBufferMemoryRequirements2),
1999         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2,                                 getImageSparseMemoryRequirements2),
2000         VK_NULL_FUNC_ENTRY(vkTrimCommandPool,                                                                   trimCommandPool),
2001         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue2,                                                                   getDeviceQueue2),
2002         VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversion,                                              createSamplerYcbcrConversion),
2003         VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversion,                                             destroySamplerYcbcrConversion),
2004         VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplate,                                    createDescriptorUpdateTemplate),
2005         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplate,                                   destroyDescriptorUpdateTemplate),
2006         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplate,                                   updateDescriptorSetWithTemplate),
2007         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupport,                                             getDescriptorSetLayoutSupport),
2008         VK_NULL_FUNC_ENTRY(vkCreateSwapchainKHR,                                                                createSwapchainKHR),
2009         VK_NULL_FUNC_ENTRY(vkDestroySwapchainKHR,                                                               destroySwapchainKHR),
2010         VK_NULL_FUNC_ENTRY(vkGetSwapchainImagesKHR,                                                             getSwapchainImagesKHR),
2011         VK_NULL_FUNC_ENTRY(vkAcquireNextImageKHR,                                                               acquireNextImageKHR),
2012         VK_NULL_FUNC_ENTRY(vkQueuePresentKHR,                                                                   queuePresentKHR),
2013         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPresentCapabilitiesKHR,                              getDeviceGroupPresentCapabilitiesKHR),
2014         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModesKHR,                              getDeviceGroupSurfacePresentModesKHR),
2015         VK_NULL_FUNC_ENTRY(vkAcquireNextImage2KHR,                                                              acquireNextImage2KHR),
2016         VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR,                                                 createSharedSwapchainsKHR),
2017         VK_NULL_FUNC_ENTRY(vkCmdDispatchBaseKHR,                                                                cmdDispatchBase),
2018         VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMaskKHR,                                                               cmdSetDeviceMask),
2019         VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeaturesKHR,                               getDeviceGroupPeerMemoryFeatures),
2020         VK_NULL_FUNC_ENTRY(vkTrimCommandPoolKHR,                                                                trimCommandPool),
2021         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHR,                                                   getMemoryWin32HandleKHR),
2022         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHR,                                 getMemoryWin32HandlePropertiesKHR),
2023         VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHR,                                                                    getMemoryFdKHR),
2024         VK_NULL_FUNC_ENTRY(vkGetMemoryFdPropertiesKHR,                                                  getMemoryFdPropertiesKHR),
2025         VK_NULL_FUNC_ENTRY(vkImportSemaphoreWin32HandleKHR,                                             importSemaphoreWin32HandleKHR),
2026         VK_NULL_FUNC_ENTRY(vkGetSemaphoreWin32HandleKHR,                                                getSemaphoreWin32HandleKHR),
2027         VK_NULL_FUNC_ENTRY(vkImportSemaphoreFdKHR,                                                              importSemaphoreFdKHR),
2028         VK_NULL_FUNC_ENTRY(vkGetSemaphoreFdKHR,                                                                 getSemaphoreFdKHR),
2029         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR,                                                   cmdPushDescriptorSetKHR),
2030         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR,                               cmdPushDescriptorSetWithTemplateKHR),
2031         VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplateKHR,                                 createDescriptorUpdateTemplate),
2032         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplateKHR,                                destroyDescriptorUpdateTemplate),
2033         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplateKHR,                                updateDescriptorSetWithTemplate),
2034         VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR,                                                             getSwapchainStatusKHR),
2035         VK_NULL_FUNC_ENTRY(vkImportFenceWin32HandleKHR,                                                 importFenceWin32HandleKHR),
2036         VK_NULL_FUNC_ENTRY(vkGetFenceWin32HandleKHR,                                                    getFenceWin32HandleKHR),
2037         VK_NULL_FUNC_ENTRY(vkImportFenceFdKHR,                                                                  importFenceFdKHR),
2038         VK_NULL_FUNC_ENTRY(vkGetFenceFdKHR,                                                                             getFenceFdKHR),
2039         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2KHR,                                   getBufferMemoryRequirements2),
2040         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2KHR,                                    getImageMemoryRequirements2),
2041         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2KHR,                              getImageSparseMemoryRequirements2),
2042         VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversionKHR,                                   createSamplerYcbcrConversion),
2043         VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversionKHR,                                  destroySamplerYcbcrConversion),
2044         VK_NULL_FUNC_ENTRY(vkBindBufferMemory2KHR,                                                              bindBufferMemory2),
2045         VK_NULL_FUNC_ENTRY(vkBindImageMemory2KHR,                                                               bindImageMemory2),
2046         VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupportKHR,                                  getDescriptorSetLayoutSupport),
2047         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectTagEXT,                                                debugMarkerSetObjectTagEXT),
2048         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectNameEXT,                                               debugMarkerSetObjectNameEXT),
2049         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerBeginEXT,                                                    cmdDebugMarkerBeginEXT),
2050         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerEndEXT,                                                              cmdDebugMarkerEndEXT),
2051         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerInsertEXT,                                                   cmdDebugMarkerInsertEXT),
2052         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCountAMD,                                                   cmdDrawIndirectCountAMD),
2053         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCountAMD,                                    cmdDrawIndexedIndirectCountAMD),
2054         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleNV,                                                    getMemoryWin32HandleNV),
2055         VK_NULL_FUNC_ENTRY(vkCmdProcessCommandsNVX,                                                             cmdProcessCommandsNVX),
2056         VK_NULL_FUNC_ENTRY(vkCmdReserveSpaceForCommandsNVX,                                             cmdReserveSpaceForCommandsNVX),
2057         VK_NULL_FUNC_ENTRY(vkCreateIndirectCommandsLayoutNVX,                                   createIndirectCommandsLayoutNVX),
2058         VK_NULL_FUNC_ENTRY(vkDestroyIndirectCommandsLayoutNVX,                                  destroyIndirectCommandsLayoutNVX),
2059         VK_NULL_FUNC_ENTRY(vkCreateObjectTableNVX,                                                              createObjectTableNVX),
2060         VK_NULL_FUNC_ENTRY(vkDestroyObjectTableNVX,                                                             destroyObjectTableNVX),
2061         VK_NULL_FUNC_ENTRY(vkRegisterObjectsNVX,                                                                registerObjectsNVX),
2062         VK_NULL_FUNC_ENTRY(vkUnregisterObjectsNVX,                                                              unregisterObjectsNVX),
2063         VK_NULL_FUNC_ENTRY(vkCmdSetViewportWScalingNV,                                                  cmdSetViewportWScalingNV),
2064         VK_NULL_FUNC_ENTRY(vkDisplayPowerControlEXT,                                                    displayPowerControlEXT),
2065         VK_NULL_FUNC_ENTRY(vkRegisterDeviceEventEXT,                                                    registerDeviceEventEXT),
2066         VK_NULL_FUNC_ENTRY(vkRegisterDisplayEventEXT,                                                   registerDisplayEventEXT),
2067         VK_NULL_FUNC_ENTRY(vkGetSwapchainCounterEXT,                                                    getSwapchainCounterEXT),
2068         VK_NULL_FUNC_ENTRY(vkGetRefreshCycleDurationGOOGLE,                                             getRefreshCycleDurationGOOGLE),
2069         VK_NULL_FUNC_ENTRY(vkGetPastPresentationTimingGOOGLE,                                   getPastPresentationTimingGOOGLE),
2070         VK_NULL_FUNC_ENTRY(vkCmdSetDiscardRectangleEXT,                                                 cmdSetDiscardRectangleEXT),
2071         VK_NULL_FUNC_ENTRY(vkSetHdrMetadataEXT,                                                                 setHdrMetadataEXT),
2072         VK_NULL_FUNC_ENTRY(vkCmdSetSampleLocationsEXT,                                                  cmdSetSampleLocationsEXT),
2073         VK_NULL_FUNC_ENTRY(vkCreateValidationCacheEXT,                                                  createValidationCacheEXT),
2074         VK_NULL_FUNC_ENTRY(vkDestroyValidationCacheEXT,                                                 destroyValidationCacheEXT),
2075         VK_NULL_FUNC_ENTRY(vkMergeValidationCachesEXT,                                                  mergeValidationCachesEXT),
2076         VK_NULL_FUNC_ENTRY(vkGetValidationCacheDataEXT,                                                 getValidationCacheDataEXT),
2077         VK_NULL_FUNC_ENTRY(vkGetMemoryAndroidHardwareBufferPropertiesANDROID,   getMemoryAndroidHardwareBufferPropertiesANDROID),
2078         VK_NULL_FUNC_ENTRY(vkGetMemoryAndroidHardwareBufferANDROID,                             getMemoryAndroidHardwareBufferANDROID),
2079 };
2080