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 allocateMemory (VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
  17 {
  18         DE_UNREF(pAllocator);
  19         VK_NULL_RETURN((*pMemory = allocateNonDispHandle<DeviceMemory, VkDeviceMemory>(device, pAllocateInfo, pAllocator)));
  20 }
  21
  22 VKAPI_ATTR VkResult VKAPI_CALL createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
  23 {
  24         DE_UNREF(pAllocator);
  25         VK_NULL_RETURN((*pFence = allocateNonDispHandle<Fence, VkFence>(device, pCreateInfo, pAllocator)));
  26 }
  27
  28 VKAPI_ATTR VkResult VKAPI_CALL createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
  29 {
  30         DE_UNREF(pAllocator);
  31         VK_NULL_RETURN((*pSemaphore = allocateNonDispHandle<Semaphore, VkSemaphore>(device, pCreateInfo, pAllocator)));
  32 }
  33
  34 VKAPI_ATTR VkResult VKAPI_CALL createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
  35 {
  36         DE_UNREF(pAllocator);
  37         VK_NULL_RETURN((*pEvent = allocateNonDispHandle<Event, VkEvent>(device, pCreateInfo, pAllocator)));
  38 }
  39
  40 VKAPI_ATTR VkResult VKAPI_CALL createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
  41 {
  42         DE_UNREF(pAllocator);
  43         VK_NULL_RETURN((*pQueryPool = allocateNonDispHandle<QueryPool, VkQueryPool>(device, pCreateInfo, pAllocator)));
  44 }
  45
  46 VKAPI_ATTR VkResult VKAPI_CALL createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
  47 {
  48         DE_UNREF(pAllocator);
  49         VK_NULL_RETURN((*pBuffer = allocateNonDispHandle<Buffer, VkBuffer>(device, pCreateInfo, pAllocator)));
  50 }
  51
  52 VKAPI_ATTR VkResult VKAPI_CALL createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
  53 {
  54         DE_UNREF(pAllocator);
  55         VK_NULL_RETURN((*pView = allocateNonDispHandle<BufferView, VkBufferView>(device, pCreateInfo, pAllocator)));
  56 }
  57
  58 VKAPI_ATTR VkResult VKAPI_CALL createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
  59 {
  60         DE_UNREF(pAllocator);
  61         VK_NULL_RETURN((*pImage = allocateNonDispHandle<Image, VkImage>(device, pCreateInfo, pAllocator)));
  62 }
  63
  64 VKAPI_ATTR VkResult VKAPI_CALL createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
  65 {
  66         DE_UNREF(pAllocator);
  67         VK_NULL_RETURN((*pView = allocateNonDispHandle<ImageView, VkImageView>(device, pCreateInfo, pAllocator)));
  68 }
  69
  70 VKAPI_ATTR VkResult VKAPI_CALL createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
  71 {
  72         DE_UNREF(pAllocator);
  73         VK_NULL_RETURN((*pShaderModule = allocateNonDispHandle<ShaderModule, VkShaderModule>(device, pCreateInfo, pAllocator)));
  74 }
  75
  76 VKAPI_ATTR VkResult VKAPI_CALL createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
  77 {
  78         DE_UNREF(pAllocator);
  79         VK_NULL_RETURN((*pPipelineCache = allocateNonDispHandle<PipelineCache, VkPipelineCache>(device, pCreateInfo, pAllocator)));
  80 }
  81
  82 VKAPI_ATTR VkResult VKAPI_CALL createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
  83 {
  84         DE_UNREF(pAllocator);
  85         VK_NULL_RETURN((*pPipelineLayout = allocateNonDispHandle<PipelineLayout, VkPipelineLayout>(device, pCreateInfo, pAllocator)));
  86 }
  87
  88 VKAPI_ATTR VkResult VKAPI_CALL createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
  89 {
  90         DE_UNREF(pAllocator);
  91         VK_NULL_RETURN((*pSampler = allocateNonDispHandle<Sampler, VkSampler>(device, pCreateInfo, pAllocator)));
  92 }
  93
  94 VKAPI_ATTR VkResult VKAPI_CALL createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
  95 {
  96         DE_UNREF(pAllocator);
  97         VK_NULL_RETURN((*pSetLayout = allocateNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(device, pCreateInfo, pAllocator)));
  98 }
  99
 100 VKAPI_ATTR VkResult VKAPI_CALL createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
 101 {
 102         DE_UNREF(pAllocator);
 103         VK_NULL_RETURN((*pDescriptorPool = allocateNonDispHandle<DescriptorPool, VkDescriptorPool>(device, pCreateInfo, pAllocator)));
 104 }
 105
 106 VKAPI_ATTR VkResult VKAPI_CALL createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
 107 {
 108         DE_UNREF(pAllocator);
 109         VK_NULL_RETURN((*pFramebuffer = allocateNonDispHandle<Framebuffer, VkFramebuffer>(device, pCreateInfo, pAllocator)));
 110 }
 111
 112 VKAPI_ATTR VkResult VKAPI_CALL createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
 113 {
 114         DE_UNREF(pAllocator);
 115         VK_NULL_RETURN((*pRenderPass = allocateNonDispHandle<RenderPass, VkRenderPass>(device, pCreateInfo, pAllocator)));
 116 }
 117
 118 VKAPI_ATTR VkResult VKAPI_CALL createCommandPool (VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
 119 {
 120         DE_UNREF(pAllocator);
 121         VK_NULL_RETURN((*pCommandPool = allocateNonDispHandle<CommandPool, VkCommandPool>(device, pCreateInfo, pAllocator)));
 122 }
 123
 124 VKAPI_ATTR VkResult VKAPI_CALL createSwapchainKHR (VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
 125 {
 126         DE_UNREF(pAllocator);
 127         VK_NULL_RETURN((*pSwapchain = allocateNonDispHandle<SwapchainKHR, VkSwapchainKHR>(device, pCreateInfo, pAllocator)));
 128 }
 129
 130 VKAPI_ATTR VkResult VKAPI_CALL createDisplayPlaneSurfaceKHR (VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
 131 {
 132         DE_UNREF(pAllocator);
 133         VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
 134 }
 135
 136 VKAPI_ATTR VkResult VKAPI_CALL createXlibSurfaceKHR (VkInstance instance, const VkXlibSurfaceCreateInfoKHR* 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 createXcbSurfaceKHR (VkInstance instance, const VkXcbSurfaceCreateInfoKHR* 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 createWaylandSurfaceKHR (VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* 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 createMirSurfaceKHR (VkInstance instance, const VkMirSurfaceCreateInfoKHR* 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 createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* 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 createWin32SurfaceKHR (VkInstance instance, const VkWin32SurfaceCreateInfoKHR* 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 createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate)
 173 {
 174         DE_UNREF(pAllocator);
 175         VK_NULL_RETURN((*pDescriptorUpdateTemplate = allocateNonDispHandle<DescriptorUpdateTemplateKHR, VkDescriptorUpdateTemplateKHR>(device, pCreateInfo, pAllocator)));
 176 }
 177
 178 VKAPI_ATTR VkResult VKAPI_CALL createSamplerYcbcrConversionKHR (VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion)
 179 {
 180         DE_UNREF(pAllocator);
 181         VK_NULL_RETURN((*pYcbcrConversion = allocateNonDispHandle<SamplerYcbcrConversionKHR, VkSamplerYcbcrConversionKHR>(device, pCreateInfo, pAllocator)));
 182 }
 183
 184 VKAPI_ATTR VkResult VKAPI_CALL createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback)
 185 {
 186         DE_UNREF(pAllocator);
 187         VK_NULL_RETURN((*pCallback = allocateNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(instance, pCreateInfo, pAllocator)));
 188 }
 189
 190 VKAPI_ATTR void VKAPI_CALL destroyInstance (VkInstance instance, const VkAllocationCallbacks* pAllocator)
 191 {
 192         freeHandle<Instance, VkInstance>(instance, pAllocator);
 193 }
 194
 195 VKAPI_ATTR void VKAPI_CALL destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator)
 196 {
 197         freeHandle<Device, VkDevice>(device, pAllocator);
 198 }
 199
 200 VKAPI_ATTR void VKAPI_CALL freeMemory (VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
 201 {
 202         DE_UNREF(device);
 203         freeNonDispHandle<DeviceMemory, VkDeviceMemory>(memory, pAllocator);
 204 }
 205
 206 VKAPI_ATTR void VKAPI_CALL destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
 207 {
 208         DE_UNREF(device);
 209         freeNonDispHandle<Fence, VkFence>(fence, pAllocator);
 210 }
 211
 212 VKAPI_ATTR void VKAPI_CALL destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
 213 {
 214         DE_UNREF(device);
 215         freeNonDispHandle<Semaphore, VkSemaphore>(semaphore, pAllocator);
 216 }
 217
 218 VKAPI_ATTR void VKAPI_CALL destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
 219 {
 220         DE_UNREF(device);
 221         freeNonDispHandle<Event, VkEvent>(event, pAllocator);
 222 }
 223
 224 VKAPI_ATTR void VKAPI_CALL destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
 225 {
 226         DE_UNREF(device);
 227         freeNonDispHandle<QueryPool, VkQueryPool>(queryPool, pAllocator);
 228 }
 229
 230 VKAPI_ATTR void VKAPI_CALL destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
 231 {
 232         DE_UNREF(device);
 233         freeNonDispHandle<Buffer, VkBuffer>(buffer, pAllocator);
 234 }
 235
 236 VKAPI_ATTR void VKAPI_CALL destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
 237 {
 238         DE_UNREF(device);
 239         freeNonDispHandle<BufferView, VkBufferView>(bufferView, pAllocator);
 240 }
 241
 242 VKAPI_ATTR void VKAPI_CALL destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 243 {
 244         DE_UNREF(device);
 245         freeNonDispHandle<Image, VkImage>(image, pAllocator);
 246 }
 247
 248 VKAPI_ATTR void VKAPI_CALL destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
 249 {
 250         DE_UNREF(device);
 251         freeNonDispHandle<ImageView, VkImageView>(imageView, pAllocator);
 252 }
 253
 254 VKAPI_ATTR void VKAPI_CALL destroyShaderModule (VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
 255 {
 256         DE_UNREF(device);
 257         freeNonDispHandle<ShaderModule, VkShaderModule>(shaderModule, pAllocator);
 258 }
 259
 260 VKAPI_ATTR void VKAPI_CALL destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
 261 {
 262         DE_UNREF(device);
 263         freeNonDispHandle<PipelineCache, VkPipelineCache>(pipelineCache, pAllocator);
 264 }
 265
 266 VKAPI_ATTR void VKAPI_CALL destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
 267 {
 268         DE_UNREF(device);
 269         freeNonDispHandle<Pipeline, VkPipeline>(pipeline, pAllocator);
 270 }
 271
 272 VKAPI_ATTR void VKAPI_CALL destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
 273 {
 274         DE_UNREF(device);
 275         freeNonDispHandle<PipelineLayout, VkPipelineLayout>(pipelineLayout, pAllocator);
 276 }
 277
 278 VKAPI_ATTR void VKAPI_CALL destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
 279 {
 280         DE_UNREF(device);
 281         freeNonDispHandle<Sampler, VkSampler>(sampler, pAllocator);
 282 }
 283
 284 VKAPI_ATTR void VKAPI_CALL destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
 285 {
 286         DE_UNREF(device);
 287         freeNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(descriptorSetLayout, pAllocator);
 288 }
 289
 290 VKAPI_ATTR void VKAPI_CALL destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
 291 {
 292         DE_UNREF(device);
 293         freeNonDispHandle<DescriptorPool, VkDescriptorPool>(descriptorPool, pAllocator);
 294 }
 295
 296 VKAPI_ATTR void VKAPI_CALL destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
 297 {
 298         DE_UNREF(device);
 299         freeNonDispHandle<Framebuffer, VkFramebuffer>(framebuffer, pAllocator);
 300 }
 301
 302 VKAPI_ATTR void VKAPI_CALL destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
 303 {
 304         DE_UNREF(device);
 305         freeNonDispHandle<RenderPass, VkRenderPass>(renderPass, pAllocator);
 306 }
 307
 308 VKAPI_ATTR void VKAPI_CALL destroyCommandPool (VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
 309 {
 310         DE_UNREF(device);
 311         freeNonDispHandle<CommandPool, VkCommandPool>(commandPool, pAllocator);
 312 }
 313
 314 VKAPI_ATTR void VKAPI_CALL destroySurfaceKHR (VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator)
 315 {
 316         DE_UNREF(instance);
 317         freeNonDispHandle<SurfaceKHR, VkSurfaceKHR>(surface, pAllocator);
 318 }
 319
 320 VKAPI_ATTR void VKAPI_CALL destroySwapchainKHR (VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
 321 {
 322         DE_UNREF(device);
 323         freeNonDispHandle<SwapchainKHR, VkSwapchainKHR>(swapchain, pAllocator);
 324 }
 325
 326 VKAPI_ATTR void VKAPI_CALL destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
 327 {
 328         DE_UNREF(device);
 329         freeNonDispHandle<DescriptorUpdateTemplateKHR, VkDescriptorUpdateTemplateKHR>(descriptorUpdateTemplate, pAllocator);
 330 }
 331
 332 VKAPI_ATTR void VKAPI_CALL destroySamplerYcbcrConversionKHR (VkDevice device, VkSamplerYcbcrConversionKHR YcbcrConversion, const VkAllocationCallbacks* pAllocator)
 333 {
 334         DE_UNREF(device);
 335         freeNonDispHandle<SamplerYcbcrConversionKHR, VkSamplerYcbcrConversionKHR>(YcbcrConversion, pAllocator);
 336 }
 337
 338 VKAPI_ATTR void VKAPI_CALL destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator)
 339 {
 340         DE_UNREF(instance);
 341         freeNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(callback, pAllocator);
 342 }
 343
 344 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (deUint32* pPropertyCount, VkLayerProperties* pProperties)
 345 {
 346         DE_UNREF(pPropertyCount);
 347         DE_UNREF(pProperties);
 348         return VK_SUCCESS;
 349 }
 350
 351 VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkLayerProperties* pProperties)
 352 {
 353         DE_UNREF(physicalDevice);
 354         DE_UNREF(pPropertyCount);
 355         DE_UNREF(pProperties);
 356         return VK_SUCCESS;
 357 }
 358
 359 VKAPI_ATTR VkResult VKAPI_CALL queueSubmit (VkQueue queue, deUint32 submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
 360 {
 361         DE_UNREF(queue);
 362         DE_UNREF(submitCount);
 363         DE_UNREF(pSubmits);
 364         DE_UNREF(fence);
 365         return VK_SUCCESS;
 366 }
 367
 368 VKAPI_ATTR VkResult VKAPI_CALL queueWaitIdle (VkQueue queue)
 369 {
 370         DE_UNREF(queue);
 371         return VK_SUCCESS;
 372 }
 373
 374 VKAPI_ATTR VkResult VKAPI_CALL deviceWaitIdle (VkDevice device)
 375 {
 376         DE_UNREF(device);
 377         return VK_SUCCESS;
 378 }
 379
 380 VKAPI_ATTR void VKAPI_CALL unmapMemory (VkDevice device, VkDeviceMemory memory)
 381 {
 382         DE_UNREF(device);
 383         DE_UNREF(memory);
 384 }
 385
 386 VKAPI_ATTR VkResult VKAPI_CALL flushMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 387 {
 388         DE_UNREF(device);
 389         DE_UNREF(memoryRangeCount);
 390         DE_UNREF(pMemoryRanges);
 391         return VK_SUCCESS;
 392 }
 393
 394 VKAPI_ATTR VkResult VKAPI_CALL invalidateMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 395 {
 396         DE_UNREF(device);
 397         DE_UNREF(memoryRangeCount);
 398         DE_UNREF(pMemoryRanges);
 399         return VK_SUCCESS;
 400 }
 401
 402 VKAPI_ATTR void VKAPI_CALL getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
 403 {
 404         DE_UNREF(device);
 405         DE_UNREF(memory);
 406         DE_UNREF(pCommittedMemoryInBytes);
 407 }
 408
 409 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 410 {
 411         DE_UNREF(device);
 412         DE_UNREF(buffer);
 413         DE_UNREF(memory);
 414         DE_UNREF(memoryOffset);
 415         return VK_SUCCESS;
 416 }
 417
 418 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 419 {
 420         DE_UNREF(device);
 421         DE_UNREF(image);
 422         DE_UNREF(memory);
 423         DE_UNREF(memoryOffset);
 424         return VK_SUCCESS;
 425 }
 426
 427 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements (VkDevice device, VkImage image, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 428 {
 429         DE_UNREF(device);
 430         DE_UNREF(image);
 431         DE_UNREF(pSparseMemoryRequirementCount);
 432         DE_UNREF(pSparseMemoryRequirements);
 433 }
 434
 435 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, deUint32* pPropertyCount, VkSparseImageFormatProperties* pProperties)
 436 {
 437         DE_UNREF(physicalDevice);
 438         DE_UNREF(format);
 439         DE_UNREF(type);
 440         DE_UNREF(samples);
 441         DE_UNREF(usage);
 442         DE_UNREF(tiling);
 443         DE_UNREF(pPropertyCount);
 444         DE_UNREF(pProperties);
 445 }
 446
 447 VKAPI_ATTR VkResult VKAPI_CALL queueBindSparse (VkQueue queue, deUint32 bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
 448 {
 449         DE_UNREF(queue);
 450         DE_UNREF(bindInfoCount);
 451         DE_UNREF(pBindInfo);
 452         DE_UNREF(fence);
 453         return VK_SUCCESS;
 454 }
 455
 456 VKAPI_ATTR VkResult VKAPI_CALL resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences)
 457 {
 458         DE_UNREF(device);
 459         DE_UNREF(fenceCount);
 460         DE_UNREF(pFences);
 461         return VK_SUCCESS;
 462 }
 463
 464 VKAPI_ATTR VkResult VKAPI_CALL getFenceStatus (VkDevice device, VkFence fence)
 465 {
 466         DE_UNREF(device);
 467         DE_UNREF(fence);
 468         return VK_SUCCESS;
 469 }
 470
 471 VKAPI_ATTR VkResult VKAPI_CALL waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout)
 472 {
 473         DE_UNREF(device);
 474         DE_UNREF(fenceCount);
 475         DE_UNREF(pFences);
 476         DE_UNREF(waitAll);
 477         DE_UNREF(timeout);
 478         return VK_SUCCESS;
 479 }
 480
 481 VKAPI_ATTR VkResult VKAPI_CALL getEventStatus (VkDevice device, VkEvent event)
 482 {
 483         DE_UNREF(device);
 484         DE_UNREF(event);
 485         return VK_SUCCESS;
 486 }
 487
 488 VKAPI_ATTR VkResult VKAPI_CALL setEvent (VkDevice device, VkEvent event)
 489 {
 490         DE_UNREF(device);
 491         DE_UNREF(event);
 492         return VK_SUCCESS;
 493 }
 494
 495 VKAPI_ATTR VkResult VKAPI_CALL resetEvent (VkDevice device, VkEvent event)
 496 {
 497         DE_UNREF(device);
 498         DE_UNREF(event);
 499         return VK_SUCCESS;
 500 }
 501
 502 VKAPI_ATTR VkResult VKAPI_CALL getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
 503 {
 504         DE_UNREF(device);
 505         DE_UNREF(queryPool);
 506         DE_UNREF(firstQuery);
 507         DE_UNREF(queryCount);
 508         DE_UNREF(dataSize);
 509         DE_UNREF(pData);
 510         DE_UNREF(stride);
 511         DE_UNREF(flags);
 512         return VK_SUCCESS;
 513 }
 514
 515 VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
 516 {
 517         DE_UNREF(device);
 518         DE_UNREF(image);
 519         DE_UNREF(pSubresource);
 520         DE_UNREF(pLayout);
 521 }
 522
 523 VKAPI_ATTR VkResult VKAPI_CALL getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, deUintptr* pDataSize, void* pData)
 524 {
 525         DE_UNREF(device);
 526         DE_UNREF(pipelineCache);
 527         DE_UNREF(pDataSize);
 528         DE_UNREF(pData);
 529         return VK_SUCCESS;
 530 }
 531
 532 VKAPI_ATTR VkResult VKAPI_CALL mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches)
 533 {
 534         DE_UNREF(device);
 535         DE_UNREF(dstCache);
 536         DE_UNREF(srcCacheCount);
 537         DE_UNREF(pSrcCaches);
 538         return VK_SUCCESS;
 539 }
 540
 541 VKAPI_ATTR void VKAPI_CALL updateDescriptorSets (VkDevice device, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
 542 {
 543         DE_UNREF(device);
 544         DE_UNREF(descriptorWriteCount);
 545         DE_UNREF(pDescriptorWrites);
 546         DE_UNREF(descriptorCopyCount);
 547         DE_UNREF(pDescriptorCopies);
 548 }
 549
 550 VKAPI_ATTR void VKAPI_CALL getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
 551 {
 552         DE_UNREF(device);
 553         DE_UNREF(renderPass);
 554         DE_UNREF(pGranularity);
 555 }
 556
 557 VKAPI_ATTR VkResult VKAPI_CALL resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 558 {
 559         DE_UNREF(device);
 560         DE_UNREF(commandPool);
 561         DE_UNREF(flags);
 562         return VK_SUCCESS;
 563 }
 564
 565 VKAPI_ATTR VkResult VKAPI_CALL beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
 566 {
 567         DE_UNREF(commandBuffer);
 568         DE_UNREF(pBeginInfo);
 569         return VK_SUCCESS;
 570 }
 571
 572 VKAPI_ATTR VkResult VKAPI_CALL endCommandBuffer (VkCommandBuffer commandBuffer)
 573 {
 574         DE_UNREF(commandBuffer);
 575         return VK_SUCCESS;
 576 }
 577
 578 VKAPI_ATTR VkResult VKAPI_CALL resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 579 {
 580         DE_UNREF(commandBuffer);
 581         DE_UNREF(flags);
 582         return VK_SUCCESS;
 583 }
 584
 585 VKAPI_ATTR void VKAPI_CALL cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 586 {
 587         DE_UNREF(commandBuffer);
 588         DE_UNREF(pipelineBindPoint);
 589         DE_UNREF(pipeline);
 590 }
 591
 592 VKAPI_ATTR void VKAPI_CALL cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports)
 593 {
 594         DE_UNREF(commandBuffer);
 595         DE_UNREF(firstViewport);
 596         DE_UNREF(viewportCount);
 597         DE_UNREF(pViewports);
 598 }
 599
 600 VKAPI_ATTR void VKAPI_CALL cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors)
 601 {
 602         DE_UNREF(commandBuffer);
 603         DE_UNREF(firstScissor);
 604         DE_UNREF(scissorCount);
 605         DE_UNREF(pScissors);
 606 }
 607
 608 VKAPI_ATTR void VKAPI_CALL cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth)
 609 {
 610         DE_UNREF(commandBuffer);
 611         DE_UNREF(lineWidth);
 612 }
 613
 614 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 615 {
 616         DE_UNREF(commandBuffer);
 617         DE_UNREF(depthBiasConstantFactor);
 618         DE_UNREF(depthBiasClamp);
 619         DE_UNREF(depthBiasSlopeFactor);
 620 }
 621
 622 VKAPI_ATTR void VKAPI_CALL cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4])
 623 {
 624         DE_UNREF(commandBuffer);
 625         DE_UNREF(blendConstants);
 626 }
 627
 628 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 629 {
 630         DE_UNREF(commandBuffer);
 631         DE_UNREF(minDepthBounds);
 632         DE_UNREF(maxDepthBounds);
 633 }
 634
 635 VKAPI_ATTR void VKAPI_CALL cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 compareMask)
 636 {
 637         DE_UNREF(commandBuffer);
 638         DE_UNREF(faceMask);
 639         DE_UNREF(compareMask);
 640 }
 641
 642 VKAPI_ATTR void VKAPI_CALL cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 writeMask)
 643 {
 644         DE_UNREF(commandBuffer);
 645         DE_UNREF(faceMask);
 646         DE_UNREF(writeMask);
 647 }
 648
 649 VKAPI_ATTR void VKAPI_CALL cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 reference)
 650 {
 651         DE_UNREF(commandBuffer);
 652         DE_UNREF(faceMask);
 653         DE_UNREF(reference);
 654 }
 655
 656 VKAPI_ATTR void VKAPI_CALL cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 descriptorSetCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets)
 657 {
 658         DE_UNREF(commandBuffer);
 659         DE_UNREF(pipelineBindPoint);
 660         DE_UNREF(layout);
 661         DE_UNREF(firstSet);
 662         DE_UNREF(descriptorSetCount);
 663         DE_UNREF(pDescriptorSets);
 664         DE_UNREF(dynamicOffsetCount);
 665         DE_UNREF(pDynamicOffsets);
 666 }
 667
 668 VKAPI_ATTR void VKAPI_CALL cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 669 {
 670         DE_UNREF(commandBuffer);
 671         DE_UNREF(buffer);
 672         DE_UNREF(offset);
 673         DE_UNREF(indexType);
 674 }
 675
 676 VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
 677 {
 678         DE_UNREF(commandBuffer);
 679         DE_UNREF(firstBinding);
 680         DE_UNREF(bindingCount);
 681         DE_UNREF(pBuffers);
 682         DE_UNREF(pOffsets);
 683 }
 684
 685 VKAPI_ATTR void VKAPI_CALL cmdDraw (VkCommandBuffer commandBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance)
 686 {
 687         DE_UNREF(commandBuffer);
 688         DE_UNREF(vertexCount);
 689         DE_UNREF(instanceCount);
 690         DE_UNREF(firstVertex);
 691         DE_UNREF(firstInstance);
 692 }
 693
 694 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexed (VkCommandBuffer commandBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance)
 695 {
 696         DE_UNREF(commandBuffer);
 697         DE_UNREF(indexCount);
 698         DE_UNREF(instanceCount);
 699         DE_UNREF(firstIndex);
 700         DE_UNREF(vertexOffset);
 701         DE_UNREF(firstInstance);
 702 }
 703
 704 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride)
 705 {
 706         DE_UNREF(commandBuffer);
 707         DE_UNREF(buffer);
 708         DE_UNREF(offset);
 709         DE_UNREF(drawCount);
 710         DE_UNREF(stride);
 711 }
 712
 713 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride)
 714 {
 715         DE_UNREF(commandBuffer);
 716         DE_UNREF(buffer);
 717         DE_UNREF(offset);
 718         DE_UNREF(drawCount);
 719         DE_UNREF(stride);
 720 }
 721
 722 VKAPI_ATTR void VKAPI_CALL cmdDispatch (VkCommandBuffer commandBuffer, deUint32 groupCountX, deUint32 groupCountY, deUint32 groupCountZ)
 723 {
 724         DE_UNREF(commandBuffer);
 725         DE_UNREF(groupCountX);
 726         DE_UNREF(groupCountY);
 727         DE_UNREF(groupCountZ);
 728 }
 729
 730 VKAPI_ATTR void VKAPI_CALL cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 731 {
 732         DE_UNREF(commandBuffer);
 733         DE_UNREF(buffer);
 734         DE_UNREF(offset);
 735 }
 736
 737 VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferCopy* pRegions)
 738 {
 739         DE_UNREF(commandBuffer);
 740         DE_UNREF(srcBuffer);
 741         DE_UNREF(dstBuffer);
 742         DE_UNREF(regionCount);
 743         DE_UNREF(pRegions);
 744 }
 745
 746 VKAPI_ATTR void VKAPI_CALL cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageCopy* pRegions)
 747 {
 748         DE_UNREF(commandBuffer);
 749         DE_UNREF(srcImage);
 750         DE_UNREF(srcImageLayout);
 751         DE_UNREF(dstImage);
 752         DE_UNREF(dstImageLayout);
 753         DE_UNREF(regionCount);
 754         DE_UNREF(pRegions);
 755 }
 756
 757 VKAPI_ATTR void VKAPI_CALL cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkFilter filter)
 758 {
 759         DE_UNREF(commandBuffer);
 760         DE_UNREF(srcImage);
 761         DE_UNREF(srcImageLayout);
 762         DE_UNREF(dstImage);
 763         DE_UNREF(dstImageLayout);
 764         DE_UNREF(regionCount);
 765         DE_UNREF(pRegions);
 766         DE_UNREF(filter);
 767 }
 768
 769 VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 770 {
 771         DE_UNREF(commandBuffer);
 772         DE_UNREF(srcBuffer);
 773         DE_UNREF(dstImage);
 774         DE_UNREF(dstImageLayout);
 775         DE_UNREF(regionCount);
 776         DE_UNREF(pRegions);
 777 }
 778
 779 VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 780 {
 781         DE_UNREF(commandBuffer);
 782         DE_UNREF(srcImage);
 783         DE_UNREF(srcImageLayout);
 784         DE_UNREF(dstBuffer);
 785         DE_UNREF(regionCount);
 786         DE_UNREF(pRegions);
 787 }
 788
 789 VKAPI_ATTR void VKAPI_CALL cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
 790 {
 791         DE_UNREF(commandBuffer);
 792         DE_UNREF(dstBuffer);
 793         DE_UNREF(dstOffset);
 794         DE_UNREF(dataSize);
 795         DE_UNREF(pData);
 796 }
 797
 798 VKAPI_ATTR void VKAPI_CALL cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, deUint32 data)
 799 {
 800         DE_UNREF(commandBuffer);
 801         DE_UNREF(dstBuffer);
 802         DE_UNREF(dstOffset);
 803         DE_UNREF(size);
 804         DE_UNREF(data);
 805 }
 806
 807 VKAPI_ATTR void VKAPI_CALL cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 808 {
 809         DE_UNREF(commandBuffer);
 810         DE_UNREF(image);
 811         DE_UNREF(imageLayout);
 812         DE_UNREF(pColor);
 813         DE_UNREF(rangeCount);
 814         DE_UNREF(pRanges);
 815 }
 816
 817 VKAPI_ATTR void VKAPI_CALL cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 818 {
 819         DE_UNREF(commandBuffer);
 820         DE_UNREF(image);
 821         DE_UNREF(imageLayout);
 822         DE_UNREF(pDepthStencil);
 823         DE_UNREF(rangeCount);
 824         DE_UNREF(pRanges);
 825 }
 826
 827 VKAPI_ATTR void VKAPI_CALL cmdClearAttachments (VkCommandBuffer commandBuffer, deUint32 attachmentCount, const VkClearAttachment* pAttachments, deUint32 rectCount, const VkClearRect* pRects)
 828 {
 829         DE_UNREF(commandBuffer);
 830         DE_UNREF(attachmentCount);
 831         DE_UNREF(pAttachments);
 832         DE_UNREF(rectCount);
 833         DE_UNREF(pRects);
 834 }
 835
 836 VKAPI_ATTR void VKAPI_CALL cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageResolve* pRegions)
 837 {
 838         DE_UNREF(commandBuffer);
 839         DE_UNREF(srcImage);
 840         DE_UNREF(srcImageLayout);
 841         DE_UNREF(dstImage);
 842         DE_UNREF(dstImageLayout);
 843         DE_UNREF(regionCount);
 844         DE_UNREF(pRegions);
 845 }
 846
 847 VKAPI_ATTR void VKAPI_CALL cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 848 {
 849         DE_UNREF(commandBuffer);
 850         DE_UNREF(event);
 851         DE_UNREF(stageMask);
 852 }
 853
 854 VKAPI_ATTR void VKAPI_CALL cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 855 {
 856         DE_UNREF(commandBuffer);
 857         DE_UNREF(event);
 858         DE_UNREF(stageMask);
 859 }
 860
 861 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)
 862 {
 863         DE_UNREF(commandBuffer);
 864         DE_UNREF(eventCount);
 865         DE_UNREF(pEvents);
 866         DE_UNREF(srcStageMask);
 867         DE_UNREF(dstStageMask);
 868         DE_UNREF(memoryBarrierCount);
 869         DE_UNREF(pMemoryBarriers);
 870         DE_UNREF(bufferMemoryBarrierCount);
 871         DE_UNREF(pBufferMemoryBarriers);
 872         DE_UNREF(imageMemoryBarrierCount);
 873         DE_UNREF(pImageMemoryBarriers);
 874 }
 875
 876 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)
 877 {
 878         DE_UNREF(commandBuffer);
 879         DE_UNREF(srcStageMask);
 880         DE_UNREF(dstStageMask);
 881         DE_UNREF(dependencyFlags);
 882         DE_UNREF(memoryBarrierCount);
 883         DE_UNREF(pMemoryBarriers);
 884         DE_UNREF(bufferMemoryBarrierCount);
 885         DE_UNREF(pBufferMemoryBarriers);
 886         DE_UNREF(imageMemoryBarrierCount);
 887         DE_UNREF(pImageMemoryBarriers);
 888 }
 889
 890 VKAPI_ATTR void VKAPI_CALL cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags)
 891 {
 892         DE_UNREF(commandBuffer);
 893         DE_UNREF(queryPool);
 894         DE_UNREF(query);
 895         DE_UNREF(flags);
 896 }
 897
 898 VKAPI_ATTR void VKAPI_CALL cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query)
 899 {
 900         DE_UNREF(commandBuffer);
 901         DE_UNREF(queryPool);
 902         DE_UNREF(query);
 903 }
 904
 905 VKAPI_ATTR void VKAPI_CALL cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount)
 906 {
 907         DE_UNREF(commandBuffer);
 908         DE_UNREF(queryPool);
 909         DE_UNREF(firstQuery);
 910         DE_UNREF(queryCount);
 911 }
 912
 913 VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query)
 914 {
 915         DE_UNREF(commandBuffer);
 916         DE_UNREF(pipelineStage);
 917         DE_UNREF(queryPool);
 918         DE_UNREF(query);
 919 }
 920
 921 VKAPI_ATTR void VKAPI_CALL cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 922 {
 923         DE_UNREF(commandBuffer);
 924         DE_UNREF(queryPool);
 925         DE_UNREF(firstQuery);
 926         DE_UNREF(queryCount);
 927         DE_UNREF(dstBuffer);
 928         DE_UNREF(dstOffset);
 929         DE_UNREF(stride);
 930         DE_UNREF(flags);
 931 }
 932
 933 VKAPI_ATTR void VKAPI_CALL cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 offset, deUint32 size, const void* pValues)
 934 {
 935         DE_UNREF(commandBuffer);
 936         DE_UNREF(layout);
 937         DE_UNREF(stageFlags);
 938         DE_UNREF(offset);
 939         DE_UNREF(size);
 940         DE_UNREF(pValues);
 941 }
 942
 943 VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
 944 {
 945         DE_UNREF(commandBuffer);
 946         DE_UNREF(pRenderPassBegin);
 947         DE_UNREF(contents);
 948 }
 949
 950 VKAPI_ATTR void VKAPI_CALL cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents)
 951 {
 952         DE_UNREF(commandBuffer);
 953         DE_UNREF(contents);
 954 }
 955
 956 VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass (VkCommandBuffer commandBuffer)
 957 {
 958         DE_UNREF(commandBuffer);
 959 }
 960
 961 VKAPI_ATTR void VKAPI_CALL cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers)
 962 {
 963         DE_UNREF(commandBuffer);
 964         DE_UNREF(commandBufferCount);
 965         DE_UNREF(pCommandBuffers);
 966 }
 967
 968 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported)
 969 {
 970         DE_UNREF(physicalDevice);
 971         DE_UNREF(queueFamilyIndex);
 972         DE_UNREF(surface);
 973         DE_UNREF(pSupported);
 974         return VK_SUCCESS;
 975 }
 976
 977 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
 978 {
 979         DE_UNREF(physicalDevice);
 980         DE_UNREF(surface);
 981         DE_UNREF(pSurfaceCapabilities);
 982         return VK_SUCCESS;
 983 }
 984
 985 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormatsKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, deUint32* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats)
 986 {
 987         DE_UNREF(physicalDevice);
 988         DE_UNREF(surface);
 989         DE_UNREF(pSurfaceFormatCount);
 990         DE_UNREF(pSurfaceFormats);
 991         return VK_SUCCESS;
 992 }
 993
 994 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, deUint32* pPresentModeCount, VkPresentModeKHR* pPresentModes)
 995 {
 996         DE_UNREF(physicalDevice);
 997         DE_UNREF(surface);
 998         DE_UNREF(pPresentModeCount);
 999         DE_UNREF(pPresentModes);
1000         return VK_SUCCESS;
1001 }
1002
1003 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainImagesKHR (VkDevice device, VkSwapchainKHR swapchain, deUint32* pSwapchainImageCount, VkImage* pSwapchainImages)
1004 {
1005         DE_UNREF(device);
1006         DE_UNREF(swapchain);
1007         DE_UNREF(pSwapchainImageCount);
1008         DE_UNREF(pSwapchainImages);
1009         return VK_SUCCESS;
1010 }
1011
1012 VKAPI_ATTR VkResult VKAPI_CALL acquireNextImageKHR (VkDevice device, VkSwapchainKHR swapchain, deUint64 timeout, VkSemaphore semaphore, VkFence fence, deUint32* pImageIndex)
1013 {
1014         DE_UNREF(device);
1015         DE_UNREF(swapchain);
1016         DE_UNREF(timeout);
1017         DE_UNREF(semaphore);
1018         DE_UNREF(fence);
1019         DE_UNREF(pImageIndex);
1020         return VK_SUCCESS;
1021 }
1022
1023 VKAPI_ATTR VkResult VKAPI_CALL queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
1024 {
1025         DE_UNREF(queue);
1026         DE_UNREF(pPresentInfo);
1027         return VK_SUCCESS;
1028 }
1029
1030 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPropertiesKHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPropertiesKHR* pProperties)
1031 {
1032         DE_UNREF(physicalDevice);
1033         DE_UNREF(pPropertyCount);
1034         DE_UNREF(pProperties);
1035         return VK_SUCCESS;
1036 }
1037
1038 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlanePropertiesKHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties)
1039 {
1040         DE_UNREF(physicalDevice);
1041         DE_UNREF(pPropertyCount);
1042         DE_UNREF(pProperties);
1043         return VK_SUCCESS;
1044 }
1045
1046 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneSupportedDisplaysKHR (VkPhysicalDevice physicalDevice, deUint32 planeIndex, deUint32* pDisplayCount, VkDisplayKHR* pDisplays)
1047 {
1048         DE_UNREF(physicalDevice);
1049         DE_UNREF(planeIndex);
1050         DE_UNREF(pDisplayCount);
1051         DE_UNREF(pDisplays);
1052         return VK_SUCCESS;
1053 }
1054
1055 VKAPI_ATTR VkResult VKAPI_CALL getDisplayModePropertiesKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, deUint32* pPropertyCount, VkDisplayModePropertiesKHR* pProperties)
1056 {
1057         DE_UNREF(physicalDevice);
1058         DE_UNREF(display);
1059         DE_UNREF(pPropertyCount);
1060         DE_UNREF(pProperties);
1061         return VK_SUCCESS;
1062 }
1063
1064 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, deUint32 planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities)
1065 {
1066         DE_UNREF(physicalDevice);
1067         DE_UNREF(mode);
1068         DE_UNREF(planeIndex);
1069         DE_UNREF(pCapabilities);
1070         return VK_SUCCESS;
1071 }
1072
1073 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXlibPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::XlibDisplayPtr dpy, pt::XlibVisualID visualID)
1074 {
1075         DE_UNREF(physicalDevice);
1076         DE_UNREF(queueFamilyIndex);
1077         DE_UNREF(dpy);
1078         DE_UNREF(visualID);
1079         return VK_SUCCESS;
1080 }
1081
1082 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXcbPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::XcbConnectionPtr connection, pt::XcbVisualid visual_id)
1083 {
1084         DE_UNREF(physicalDevice);
1085         DE_UNREF(queueFamilyIndex);
1086         DE_UNREF(connection);
1087         DE_UNREF(visual_id);
1088         return VK_SUCCESS;
1089 }
1090
1091 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWaylandPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::WaylandDisplayPtr display)
1092 {
1093         DE_UNREF(physicalDevice);
1094         DE_UNREF(queueFamilyIndex);
1095         DE_UNREF(display);
1096         return VK_SUCCESS;
1097 }
1098
1099 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceMirPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::MirConnectionPtr connection)
1100 {
1101         DE_UNREF(physicalDevice);
1102         DE_UNREF(queueFamilyIndex);
1103         DE_UNREF(connection);
1104         return VK_SUCCESS;
1105 }
1106
1107 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex)
1108 {
1109         DE_UNREF(physicalDevice);
1110         DE_UNREF(queueFamilyIndex);
1111         return VK_SUCCESS;
1112 }
1113
1114 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFormatProperties2KHR (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties)
1115 {
1116         DE_UNREF(physicalDevice);
1117         DE_UNREF(format);
1118         DE_UNREF(pFormatProperties);
1119 }
1120
1121 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties)
1122 {
1123         DE_UNREF(physicalDevice);
1124         DE_UNREF(pImageFormatInfo);
1125         DE_UNREF(pImageFormatProperties);
1126         return VK_SUCCESS;
1127 }
1128
1129 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties)
1130 {
1131         DE_UNREF(physicalDevice);
1132         DE_UNREF(pQueueFamilyPropertyCount);
1133         DE_UNREF(pQueueFamilyProperties);
1134 }
1135
1136 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMemoryProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties)
1137 {
1138         DE_UNREF(physicalDevice);
1139         DE_UNREF(pMemoryProperties);
1140 }
1141
1142 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, deUint32* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties)
1143 {
1144         DE_UNREF(physicalDevice);
1145         DE_UNREF(pFormatInfo);
1146         DE_UNREF(pPropertyCount);
1147         DE_UNREF(pProperties);
1148 }
1149
1150 VKAPI_ATTR void VKAPI_CALL trimCommandPoolKHR (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags)
1151 {
1152         DE_UNREF(device);
1153         DE_UNREF(commandPool);
1154         DE_UNREF(flags);
1155 }
1156
1157 VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
1158 {
1159         DE_UNREF(commandBuffer);
1160         DE_UNREF(pipelineBindPoint);
1161         DE_UNREF(layout);
1162         DE_UNREF(set);
1163         DE_UNREF(descriptorWriteCount);
1164         DE_UNREF(pDescriptorWrites);
1165 }
1166
1167 VKAPI_ATTR void VKAPI_CALL updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData)
1168 {
1169         DE_UNREF(device);
1170         DE_UNREF(descriptorSet);
1171         DE_UNREF(descriptorUpdateTemplate);
1172         DE_UNREF(pData);
1173 }
1174
1175 VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData)
1176 {
1177         DE_UNREF(commandBuffer);
1178         DE_UNREF(descriptorUpdateTemplate);
1179         DE_UNREF(layout);
1180         DE_UNREF(set);
1181         DE_UNREF(pData);
1182 }
1183
1184 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain)
1185 {
1186         DE_UNREF(device);
1187         DE_UNREF(swapchain);
1188         return VK_SUCCESS;
1189 }
1190
1191 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
1192 {
1193         DE_UNREF(physicalDevice);
1194         DE_UNREF(pSurfaceInfo);
1195         DE_UNREF(pSurfaceCapabilities);
1196         return VK_SUCCESS;
1197 }
1198
1199 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats)
1200 {
1201         DE_UNREF(physicalDevice);
1202         DE_UNREF(pSurfaceInfo);
1203         DE_UNREF(pSurfaceFormatCount);
1204         DE_UNREF(pSurfaceFormats);
1205         return VK_SUCCESS;
1206 }
1207
1208 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalFencePropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties)
1209 {
1210         DE_UNREF(physicalDevice);
1211         DE_UNREF(pExternalFenceInfo);
1212         DE_UNREF(pExternalFenceProperties);
1213 }
1214
1215 VKAPI_ATTR VkResult VKAPI_CALL importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
1216 {
1217         DE_UNREF(device);
1218         DE_UNREF(pImportFenceWin32HandleInfo);
1219         return VK_SUCCESS;
1220 }
1221
1222 VKAPI_ATTR VkResult VKAPI_CALL getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
1223 {
1224         DE_UNREF(device);
1225         DE_UNREF(pGetWin32HandleInfo);
1226         DE_UNREF(pHandle);
1227         return VK_SUCCESS;
1228 }
1229
1230 VKAPI_ATTR VkResult VKAPI_CALL importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
1231 {
1232         DE_UNREF(device);
1233         DE_UNREF(pImportFenceFdInfo);
1234         return VK_SUCCESS;
1235 }
1236
1237 VKAPI_ATTR VkResult VKAPI_CALL getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd)
1238 {
1239         DE_UNREF(device);
1240         DE_UNREF(pGetFdInfo);
1241         DE_UNREF(pFd);
1242         return VK_SUCCESS;
1243 }
1244
1245 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements2KHR (VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements)
1246 {
1247         DE_UNREF(device);
1248         DE_UNREF(pInfo);
1249         DE_UNREF(pSparseMemoryRequirementCount);
1250         DE_UNREF(pSparseMemoryRequirements);
1251 }
1252
1253 VKAPI_ATTR void VKAPI_CALL debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage)
1254 {
1255         DE_UNREF(instance);
1256         DE_UNREF(flags);
1257         DE_UNREF(objectType);
1258         DE_UNREF(object);
1259         DE_UNREF(location);
1260         DE_UNREF(messageCode);
1261         DE_UNREF(pLayerPrefix);
1262         DE_UNREF(pMessage);
1263 }
1264
1265 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalBufferPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties)
1266 {
1267         DE_UNREF(physicalDevice);
1268         DE_UNREF(pExternalBufferInfo);
1269         DE_UNREF(pExternalBufferProperties);
1270 }
1271
1272 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
1273 {
1274         DE_UNREF(device);
1275         DE_UNREF(pGetWin32HandleInfo);
1276         DE_UNREF(pHandle);
1277         return VK_SUCCESS;
1278 }
1279
1280 VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
1281 {
1282         DE_UNREF(device);
1283         DE_UNREF(handleType);
1284         DE_UNREF(handle);
1285         DE_UNREF(pMemoryWin32HandleProperties);
1286         return VK_SUCCESS;
1287 }
1288
1289 VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd)
1290 {
1291         DE_UNREF(device);
1292         DE_UNREF(pGetFdInfo);
1293         DE_UNREF(pFd);
1294         return VK_SUCCESS;
1295 }
1296
1297 VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdPropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties)
1298 {
1299         DE_UNREF(device);
1300         DE_UNREF(handleType);
1301         DE_UNREF(fd);
1302         DE_UNREF(pMemoryFdProperties);
1303         return VK_SUCCESS;
1304 }
1305
1306 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalSemaphorePropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties)
1307 {
1308         DE_UNREF(physicalDevice);
1309         DE_UNREF(pExternalSemaphoreInfo);
1310         DE_UNREF(pExternalSemaphoreProperties);
1311 }
1312
1313 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreWin32HandleKHR (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
1314 {
1315         DE_UNREF(device);
1316         DE_UNREF(pImportSemaphoreWin32HandleInfo);
1317         return VK_SUCCESS;
1318 }
1319
1320 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreWin32HandleKHR (VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
1321 {
1322         DE_UNREF(device);
1323         DE_UNREF(pGetWin32HandleInfo);
1324         DE_UNREF(pHandle);
1325         return VK_SUCCESS;
1326 }
1327
1328 VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreFdKHR (VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
1329 {
1330         DE_UNREF(device);
1331         DE_UNREF(pImportSemaphoreFdInfo);
1332         return VK_SUCCESS;
1333 }
1334
1335 VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd)
1336 {
1337         DE_UNREF(device);
1338         DE_UNREF(pGetFdInfo);
1339         DE_UNREF(pFd);
1340         return VK_SUCCESS;
1341 }
1342
1343 VKAPI_ATTR VkResult VKAPI_CALL getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
1344 {
1345         DE_UNREF(device);
1346         DE_UNREF(swapchain);
1347         DE_UNREF(pDisplayTimingProperties);
1348         return VK_SUCCESS;
1349 }
1350
1351 VKAPI_ATTR VkResult VKAPI_CALL getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, deUint32* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings)
1352 {
1353         DE_UNREF(device);
1354         DE_UNREF(swapchain);
1355         DE_UNREF(pPresentationTimingCount);
1356         DE_UNREF(pPresentationTimings);
1357         return VK_SUCCESS;
1358 }
1359
1360 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory2KHR (VkDevice device, deUint32 bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos)
1361 {
1362         DE_UNREF(device);
1363         DE_UNREF(bindInfoCount);
1364         DE_UNREF(pBindInfos);
1365         return VK_SUCCESS;
1366 }
1367
1368 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory2KHR (VkDevice device, deUint32 bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos)
1369 {
1370         DE_UNREF(device);
1371         DE_UNREF(bindInfoCount);
1372         DE_UNREF(pBindInfos);
1373         return VK_SUCCESS;
1374 }
1375
1376 static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
1377 {
1378         VK_NULL_FUNC_ENTRY(vkCreateInstance,                                            createInstance),
1379         VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr,                                       getInstanceProcAddr),
1380         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceExtensionProperties,      enumerateInstanceExtensionProperties),
1381         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceLayerProperties,          enumerateInstanceLayerProperties),
1382 };
1383
1384 static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
1385 {
1386         VK_NULL_FUNC_ENTRY(vkDestroyInstance,                                                                   destroyInstance),
1387         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDevices,                                                  enumeratePhysicalDevices),
1388         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures,                                                 getPhysicalDeviceFeatures),
1389         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties,                                 getPhysicalDeviceFormatProperties),
1390         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties,                    getPhysicalDeviceImageFormatProperties),
1391         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties,                                               getPhysicalDeviceProperties),
1392         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties,                    getPhysicalDeviceQueueFamilyProperties),
1393         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties,                                 getPhysicalDeviceMemoryProperties),
1394         VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr,                                                                 getDeviceProcAddr),
1395         VK_NULL_FUNC_ENTRY(vkCreateDevice,                                                                              createDevice),
1396         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceExtensionProperties,                                enumerateDeviceExtensionProperties),
1397         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceLayerProperties,                                    enumerateDeviceLayerProperties),
1398         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties,              getPhysicalDeviceSparseImageFormatProperties),
1399         VK_NULL_FUNC_ENTRY(vkDestroySurfaceKHR,                                                                 destroySurfaceKHR),
1400         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceSupportKHR,                                getPhysicalDeviceSurfaceSupportKHR),
1401         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilitiesKHR,                   getPhysicalDeviceSurfaceCapabilitiesKHR),
1402         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormatsKHR,                                getPhysicalDeviceSurfaceFormatsKHR),
1403         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModesKHR,                   getPhysicalDeviceSurfacePresentModesKHR),
1404         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPropertiesKHR,                             getPhysicalDeviceDisplayPropertiesKHR),
1405         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlanePropertiesKHR,                getPhysicalDeviceDisplayPlanePropertiesKHR),
1406         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneSupportedDisplaysKHR,                               getDisplayPlaneSupportedDisplaysKHR),
1407         VK_NULL_FUNC_ENTRY(vkGetDisplayModePropertiesKHR,                                               getDisplayModePropertiesKHR),
1408         VK_NULL_FUNC_ENTRY(vkCreateDisplayModeKHR,                                                              createDisplayModeKHR),
1409         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilitiesKHR,                                    getDisplayPlaneCapabilitiesKHR),
1410         VK_NULL_FUNC_ENTRY(vkCreateDisplayPlaneSurfaceKHR,                                              createDisplayPlaneSurfaceKHR),
1411         VK_NULL_FUNC_ENTRY(vkCreateXlibSurfaceKHR,                                                              createXlibSurfaceKHR),
1412         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXlibPresentationSupportKHR,               getPhysicalDeviceXlibPresentationSupportKHR),
1413         VK_NULL_FUNC_ENTRY(vkCreateXcbSurfaceKHR,                                                               createXcbSurfaceKHR),
1414         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXcbPresentationSupportKHR,                getPhysicalDeviceXcbPresentationSupportKHR),
1415         VK_NULL_FUNC_ENTRY(vkCreateWaylandSurfaceKHR,                                                   createWaylandSurfaceKHR),
1416         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWaylandPresentationSupportKHR,    getPhysicalDeviceWaylandPresentationSupportKHR),
1417         VK_NULL_FUNC_ENTRY(vkCreateMirSurfaceKHR,                                                               createMirSurfaceKHR),
1418         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMirPresentationSupportKHR,                getPhysicalDeviceMirPresentationSupportKHR),
1419         VK_NULL_FUNC_ENTRY(vkCreateAndroidSurfaceKHR,                                                   createAndroidSurfaceKHR),
1420         VK_NULL_FUNC_ENTRY(vkCreateWin32SurfaceKHR,                                                             createWin32SurfaceKHR),
1421         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWin32PresentationSupportKHR,              getPhysicalDeviceWin32PresentationSupportKHR),
1422         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures2KHR,                                             getPhysicalDeviceFeatures2KHR),
1423         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties2KHR,                                   getPhysicalDeviceProperties2KHR),
1424         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties2KHR,                             getPhysicalDeviceFormatProperties2KHR),
1425         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties2KHR,                getPhysicalDeviceImageFormatProperties2KHR),
1426         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2KHR,                getPhysicalDeviceQueueFamilyProperties2KHR),
1427         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2KHR,                             getPhysicalDeviceMemoryProperties2KHR),
1428         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2KHR,  getPhysicalDeviceSparseImageFormatProperties2KHR),
1429         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2KHR,                  getPhysicalDeviceSurfaceCapabilities2KHR),
1430         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormats2KHR,                               getPhysicalDeviceSurfaceFormats2KHR),
1431         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFencePropertiesKHR,               getPhysicalDeviceExternalFencePropertiesKHR),
1432         VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT,                                              createDebugReportCallbackEXT),
1433         VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT,                                             destroyDebugReportCallbackEXT),
1434         VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT,                                                             debugReportMessageEXT),
1435         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferPropertiesKHR,              getPhysicalDeviceExternalBufferPropertiesKHR),
1436         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,   getPhysicalDeviceExternalSemaphorePropertiesKHR),
1437 };
1438
1439 static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
1440 {
1441         VK_NULL_FUNC_ENTRY(vkDestroyDevice,                                                     destroyDevice),
1442         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue,                                            getDeviceQueue),
1443         VK_NULL_FUNC_ENTRY(vkQueueSubmit,                                                       queueSubmit),
1444         VK_NULL_FUNC_ENTRY(vkQueueWaitIdle,                                                     queueWaitIdle),
1445         VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle,                                            deviceWaitIdle),
1446         VK_NULL_FUNC_ENTRY(vkAllocateMemory,                                            allocateMemory),
1447         VK_NULL_FUNC_ENTRY(vkFreeMemory,                                                        freeMemory),
1448         VK_NULL_FUNC_ENTRY(vkMapMemory,                                                         mapMemory),
1449         VK_NULL_FUNC_ENTRY(vkUnmapMemory,                                                       unmapMemory),
1450         VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges,                           flushMappedMemoryRanges),
1451         VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges,                      invalidateMappedMemoryRanges),
1452         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment,                         getDeviceMemoryCommitment),
1453         VK_NULL_FUNC_ENTRY(vkBindBufferMemory,                                          bindBufferMemory),
1454         VK_NULL_FUNC_ENTRY(vkBindImageMemory,                                           bindImageMemory),
1455         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements,                       getBufferMemoryRequirements),
1456         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements,                        getImageMemoryRequirements),
1457         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements,          getImageSparseMemoryRequirements),
1458         VK_NULL_FUNC_ENTRY(vkQueueBindSparse,                                           queueBindSparse),
1459         VK_NULL_FUNC_ENTRY(vkCreateFence,                                                       createFence),
1460         VK_NULL_FUNC_ENTRY(vkDestroyFence,                                                      destroyFence),
1461         VK_NULL_FUNC_ENTRY(vkResetFences,                                                       resetFences),
1462         VK_NULL_FUNC_ENTRY(vkGetFenceStatus,                                            getFenceStatus),
1463         VK_NULL_FUNC_ENTRY(vkWaitForFences,                                                     waitForFences),
1464         VK_NULL_FUNC_ENTRY(vkCreateSemaphore,                                           createSemaphore),
1465         VK_NULL_FUNC_ENTRY(vkDestroySemaphore,                                          destroySemaphore),
1466         VK_NULL_FUNC_ENTRY(vkCreateEvent,                                                       createEvent),
1467         VK_NULL_FUNC_ENTRY(vkDestroyEvent,                                                      destroyEvent),
1468         VK_NULL_FUNC_ENTRY(vkGetEventStatus,                                            getEventStatus),
1469         VK_NULL_FUNC_ENTRY(vkSetEvent,                                                          setEvent),
1470         VK_NULL_FUNC_ENTRY(vkResetEvent,                                                        resetEvent),
1471         VK_NULL_FUNC_ENTRY(vkCreateQueryPool,                                           createQueryPool),
1472         VK_NULL_FUNC_ENTRY(vkDestroyQueryPool,                                          destroyQueryPool),
1473         VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults,                                       getQueryPoolResults),
1474         VK_NULL_FUNC_ENTRY(vkCreateBuffer,                                                      createBuffer),
1475         VK_NULL_FUNC_ENTRY(vkDestroyBuffer,                                                     destroyBuffer),
1476         VK_NULL_FUNC_ENTRY(vkCreateBufferView,                                          createBufferView),
1477         VK_NULL_FUNC_ENTRY(vkDestroyBufferView,                                         destroyBufferView),
1478         VK_NULL_FUNC_ENTRY(vkCreateImage,                                                       createImage),
1479         VK_NULL_FUNC_ENTRY(vkDestroyImage,                                                      destroyImage),
1480         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout,                         getImageSubresourceLayout),
1481         VK_NULL_FUNC_ENTRY(vkCreateImageView,                                           createImageView),
1482         VK_NULL_FUNC_ENTRY(vkDestroyImageView,                                          destroyImageView),
1483         VK_NULL_FUNC_ENTRY(vkCreateShaderModule,                                        createShaderModule),
1484         VK_NULL_FUNC_ENTRY(vkDestroyShaderModule,                                       destroyShaderModule),
1485         VK_NULL_FUNC_ENTRY(vkCreatePipelineCache,                                       createPipelineCache),
1486         VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache,                                      destroyPipelineCache),
1487         VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData,                                      getPipelineCacheData),
1488         VK_NULL_FUNC_ENTRY(vkMergePipelineCaches,                                       mergePipelineCaches),
1489         VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines,                           createGraphicsPipelines),
1490         VK_NULL_FUNC_ENTRY(vkCreateComputePipelines,                            createComputePipelines),
1491         VK_NULL_FUNC_ENTRY(vkDestroyPipeline,                                           destroyPipeline),
1492         VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout,                                      createPipelineLayout),
1493         VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout,                                     destroyPipelineLayout),
1494         VK_NULL_FUNC_ENTRY(vkCreateSampler,                                                     createSampler),
1495         VK_NULL_FUNC_ENTRY(vkDestroySampler,                                            destroySampler),
1496         VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout,                         createDescriptorSetLayout),
1497         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout,                        destroyDescriptorSetLayout),
1498         VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool,                                      createDescriptorPool),
1499         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool,                                     destroyDescriptorPool),
1500         VK_NULL_FUNC_ENTRY(vkResetDescriptorPool,                                       resetDescriptorPool),
1501         VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets,                            allocateDescriptorSets),
1502         VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets,                                        freeDescriptorSets),
1503         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets,                                      updateDescriptorSets),
1504         VK_NULL_FUNC_ENTRY(vkCreateFramebuffer,                                         createFramebuffer),
1505         VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer,                                        destroyFramebuffer),
1506         VK_NULL_FUNC_ENTRY(vkCreateRenderPass,                                          createRenderPass),
1507         VK_NULL_FUNC_ENTRY(vkDestroyRenderPass,                                         destroyRenderPass),
1508         VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity,                          getRenderAreaGranularity),
1509         VK_NULL_FUNC_ENTRY(vkCreateCommandPool,                                         createCommandPool),
1510         VK_NULL_FUNC_ENTRY(vkDestroyCommandPool,                                        destroyCommandPool),
1511         VK_NULL_FUNC_ENTRY(vkResetCommandPool,                                          resetCommandPool),
1512         VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers,                            allocateCommandBuffers),
1513         VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers,                                        freeCommandBuffers),
1514         VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer,                                        beginCommandBuffer),
1515         VK_NULL_FUNC_ENTRY(vkEndCommandBuffer,                                          endCommandBuffer),
1516         VK_NULL_FUNC_ENTRY(vkResetCommandBuffer,                                        resetCommandBuffer),
1517         VK_NULL_FUNC_ENTRY(vkCmdBindPipeline,                                           cmdBindPipeline),
1518         VK_NULL_FUNC_ENTRY(vkCmdSetViewport,                                            cmdSetViewport),
1519         VK_NULL_FUNC_ENTRY(vkCmdSetScissor,                                                     cmdSetScissor),
1520         VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth,                                           cmdSetLineWidth),
1521         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias,                                           cmdSetDepthBias),
1522         VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants,                                      cmdSetBlendConstants),
1523         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds,                                         cmdSetDepthBounds),
1524         VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask,                          cmdSetStencilCompareMask),
1525         VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask,                            cmdSetStencilWriteMask),
1526         VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference,                            cmdSetStencilReference),
1527         VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets,                                     cmdBindDescriptorSets),
1528         VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer,                                        cmdBindIndexBuffer),
1529         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers,                                      cmdBindVertexBuffers),
1530         VK_NULL_FUNC_ENTRY(vkCmdDraw,                                                           cmdDraw),
1531         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed,                                            cmdDrawIndexed),
1532         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect,                                           cmdDrawIndirect),
1533         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect,                            cmdDrawIndexedIndirect),
1534         VK_NULL_FUNC_ENTRY(vkCmdDispatch,                                                       cmdDispatch),
1535         VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect,                                       cmdDispatchIndirect),
1536         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer,                                                     cmdCopyBuffer),
1537         VK_NULL_FUNC_ENTRY(vkCmdCopyImage,                                                      cmdCopyImage),
1538         VK_NULL_FUNC_ENTRY(vkCmdBlitImage,                                                      cmdBlitImage),
1539         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage,                                      cmdCopyBufferToImage),
1540         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer,                                      cmdCopyImageToBuffer),
1541         VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer,                                           cmdUpdateBuffer),
1542         VK_NULL_FUNC_ENTRY(vkCmdFillBuffer,                                                     cmdFillBuffer),
1543         VK_NULL_FUNC_ENTRY(vkCmdClearColorImage,                                        cmdClearColorImage),
1544         VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage,                         cmdClearDepthStencilImage),
1545         VK_NULL_FUNC_ENTRY(vkCmdClearAttachments,                                       cmdClearAttachments),
1546         VK_NULL_FUNC_ENTRY(vkCmdResolveImage,                                           cmdResolveImage),
1547         VK_NULL_FUNC_ENTRY(vkCmdSetEvent,                                                       cmdSetEvent),
1548         VK_NULL_FUNC_ENTRY(vkCmdResetEvent,                                                     cmdResetEvent),
1549         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents,                                                     cmdWaitEvents),
1550         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier,                                        cmdPipelineBarrier),
1551         VK_NULL_FUNC_ENTRY(vkCmdBeginQuery,                                                     cmdBeginQuery),
1552         VK_NULL_FUNC_ENTRY(vkCmdEndQuery,                                                       cmdEndQuery),
1553         VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool,                                         cmdResetQueryPool),
1554         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp,                                         cmdWriteTimestamp),
1555         VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults,                           cmdCopyQueryPoolResults),
1556         VK_NULL_FUNC_ENTRY(vkCmdPushConstants,                                          cmdPushConstants),
1557         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass,                                        cmdBeginRenderPass),
1558         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass,                                            cmdNextSubpass),
1559         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass,                                          cmdEndRenderPass),
1560         VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands,                                        cmdExecuteCommands),
1561         VK_NULL_FUNC_ENTRY(vkCreateSwapchainKHR,                                        createSwapchainKHR),
1562         VK_NULL_FUNC_ENTRY(vkDestroySwapchainKHR,                                       destroySwapchainKHR),
1563         VK_NULL_FUNC_ENTRY(vkGetSwapchainImagesKHR,                                     getSwapchainImagesKHR),
1564         VK_NULL_FUNC_ENTRY(vkAcquireNextImageKHR,                                       acquireNextImageKHR),
1565         VK_NULL_FUNC_ENTRY(vkQueuePresentKHR,                                           queuePresentKHR),
1566         VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR,                         createSharedSwapchainsKHR),
1567         VK_NULL_FUNC_ENTRY(vkTrimCommandPoolKHR,                                        trimCommandPoolKHR),
1568         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR,                           cmdPushDescriptorSetKHR),
1569         VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplateKHR,         createDescriptorUpdateTemplateKHR),
1570         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplateKHR,        destroyDescriptorUpdateTemplateKHR),
1571         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplateKHR,        updateDescriptorSetWithTemplateKHR),
1572         VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR,       cmdPushDescriptorSetWithTemplateKHR),
1573         VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR,                                     getSwapchainStatusKHR),
1574         VK_NULL_FUNC_ENTRY(vkImportFenceWin32HandleKHR,                         importFenceWin32HandleKHR),
1575         VK_NULL_FUNC_ENTRY(vkGetFenceWin32HandleKHR,                            getFenceWin32HandleKHR),
1576         VK_NULL_FUNC_ENTRY(vkImportFenceFdKHR,                                          importFenceFdKHR),
1577         VK_NULL_FUNC_ENTRY(vkGetFenceFdKHR,                                                     getFenceFdKHR),
1578         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2KHR,            getImageMemoryRequirements2KHR),
1579         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2KHR,           getBufferMemoryRequirements2KHR),
1580         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2KHR,      getImageSparseMemoryRequirements2KHR),
1581         VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversionKHR,           createSamplerYcbcrConversionKHR),
1582         VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversionKHR,          destroySamplerYcbcrConversionKHR),
1583         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHR,                           getMemoryWin32HandleKHR),
1584         VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHR,         getMemoryWin32HandlePropertiesKHR),
1585         VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHR,                                            getMemoryFdKHR),
1586         VK_NULL_FUNC_ENTRY(vkGetMemoryFdPropertiesKHR,                          getMemoryFdPropertiesKHR),
1587         VK_NULL_FUNC_ENTRY(vkImportSemaphoreWin32HandleKHR,                     importSemaphoreWin32HandleKHR),
1588         VK_NULL_FUNC_ENTRY(vkGetSemaphoreWin32HandleKHR,                        getSemaphoreWin32HandleKHR),
1589         VK_NULL_FUNC_ENTRY(vkImportSemaphoreFdKHR,                                      importSemaphoreFdKHR),
1590         VK_NULL_FUNC_ENTRY(vkGetSemaphoreFdKHR,                                         getSemaphoreFdKHR),
1591         VK_NULL_FUNC_ENTRY(vkGetRefreshCycleDurationGOOGLE,                     getRefreshCycleDurationGOOGLE),
1592         VK_NULL_FUNC_ENTRY(vkGetPastPresentationTimingGOOGLE,           getPastPresentationTimingGOOGLE),
1593         VK_NULL_FUNC_ENTRY(vkBindBufferMemory2KHR,                                      bindBufferMemory2KHR),
1594         VK_NULL_FUNC_ENTRY(vkBindImageMemory2KHR,                                       bindImageMemory2KHR),
1595 };
1596