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 createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback)
 173 {
 174         DE_UNREF(pAllocator);
 175         VK_NULL_RETURN((*pCallback = allocateNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(instance, pCreateInfo, pAllocator)));
 176 }
 177
 178 VKAPI_ATTR void VKAPI_CALL destroyInstance (VkInstance instance, const VkAllocationCallbacks* pAllocator)
 179 {
 180         freeHandle<Instance, VkInstance>(instance, pAllocator);
 181 }
 182
 183 VKAPI_ATTR void VKAPI_CALL destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator)
 184 {
 185         freeHandle<Device, VkDevice>(device, pAllocator);
 186 }
 187
 188 VKAPI_ATTR void VKAPI_CALL freeMemory (VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
 189 {
 190         DE_UNREF(device);
 191         freeNonDispHandle<DeviceMemory, VkDeviceMemory>(memory, pAllocator);
 192 }
 193
 194 VKAPI_ATTR void VKAPI_CALL destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
 195 {
 196         DE_UNREF(device);
 197         freeNonDispHandle<Fence, VkFence>(fence, pAllocator);
 198 }
 199
 200 VKAPI_ATTR void VKAPI_CALL destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
 201 {
 202         DE_UNREF(device);
 203         freeNonDispHandle<Semaphore, VkSemaphore>(semaphore, pAllocator);
 204 }
 205
 206 VKAPI_ATTR void VKAPI_CALL destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
 207 {
 208         DE_UNREF(device);
 209         freeNonDispHandle<Event, VkEvent>(event, pAllocator);
 210 }
 211
 212 VKAPI_ATTR void VKAPI_CALL destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
 213 {
 214         DE_UNREF(device);
 215         freeNonDispHandle<QueryPool, VkQueryPool>(queryPool, pAllocator);
 216 }
 217
 218 VKAPI_ATTR void VKAPI_CALL destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
 219 {
 220         DE_UNREF(device);
 221         freeNonDispHandle<Buffer, VkBuffer>(buffer, pAllocator);
 222 }
 223
 224 VKAPI_ATTR void VKAPI_CALL destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
 225 {
 226         DE_UNREF(device);
 227         freeNonDispHandle<BufferView, VkBufferView>(bufferView, pAllocator);
 228 }
 229
 230 VKAPI_ATTR void VKAPI_CALL destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 231 {
 232         DE_UNREF(device);
 233         freeNonDispHandle<Image, VkImage>(image, pAllocator);
 234 }
 235
 236 VKAPI_ATTR void VKAPI_CALL destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
 237 {
 238         DE_UNREF(device);
 239         freeNonDispHandle<ImageView, VkImageView>(imageView, pAllocator);
 240 }
 241
 242 VKAPI_ATTR void VKAPI_CALL destroyShaderModule (VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
 243 {
 244         DE_UNREF(device);
 245         freeNonDispHandle<ShaderModule, VkShaderModule>(shaderModule, pAllocator);
 246 }
 247
 248 VKAPI_ATTR void VKAPI_CALL destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
 249 {
 250         DE_UNREF(device);
 251         freeNonDispHandle<PipelineCache, VkPipelineCache>(pipelineCache, pAllocator);
 252 }
 253
 254 VKAPI_ATTR void VKAPI_CALL destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
 255 {
 256         DE_UNREF(device);
 257         freeNonDispHandle<Pipeline, VkPipeline>(pipeline, pAllocator);
 258 }
 259
 260 VKAPI_ATTR void VKAPI_CALL destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
 261 {
 262         DE_UNREF(device);
 263         freeNonDispHandle<PipelineLayout, VkPipelineLayout>(pipelineLayout, pAllocator);
 264 }
 265
 266 VKAPI_ATTR void VKAPI_CALL destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
 267 {
 268         DE_UNREF(device);
 269         freeNonDispHandle<Sampler, VkSampler>(sampler, pAllocator);
 270 }
 271
 272 VKAPI_ATTR void VKAPI_CALL destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
 273 {
 274         DE_UNREF(device);
 275         freeNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(descriptorSetLayout, pAllocator);
 276 }
 277
 278 VKAPI_ATTR void VKAPI_CALL destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
 279 {
 280         DE_UNREF(device);
 281         freeNonDispHandle<DescriptorPool, VkDescriptorPool>(descriptorPool, pAllocator);
 282 }
 283
 284 VKAPI_ATTR void VKAPI_CALL destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
 285 {
 286         DE_UNREF(device);
 287         freeNonDispHandle<Framebuffer, VkFramebuffer>(framebuffer, pAllocator);
 288 }
 289
 290 VKAPI_ATTR void VKAPI_CALL destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
 291 {
 292         DE_UNREF(device);
 293         freeNonDispHandle<RenderPass, VkRenderPass>(renderPass, pAllocator);
 294 }
 295
 296 VKAPI_ATTR void VKAPI_CALL destroyCommandPool (VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
 297 {
 298         DE_UNREF(device);
 299         freeNonDispHandle<CommandPool, VkCommandPool>(commandPool, pAllocator);
 300 }
 301
 302 VKAPI_ATTR void VKAPI_CALL destroySurfaceKHR (VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator)
 303 {
 304         DE_UNREF(instance);
 305         freeNonDispHandle<SurfaceKHR, VkSurfaceKHR>(surface, pAllocator);
 306 }
 307
 308 VKAPI_ATTR void VKAPI_CALL destroySwapchainKHR (VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
 309 {
 310         DE_UNREF(device);
 311         freeNonDispHandle<SwapchainKHR, VkSwapchainKHR>(swapchain, pAllocator);
 312 }
 313
 314 VKAPI_ATTR void VKAPI_CALL destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator)
 315 {
 316         DE_UNREF(instance);
 317         freeNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(callback, pAllocator);
 318 }
 319
 320 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
 321 {
 322         DE_UNREF(physicalDevice);
 323         DE_UNREF(pFeatures);
 324 }
 325
 326 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
 327 {
 328         DE_UNREF(physicalDevice);
 329         DE_UNREF(format);
 330         DE_UNREF(type);
 331         DE_UNREF(tiling);
 332         DE_UNREF(usage);
 333         DE_UNREF(flags);
 334         DE_UNREF(pImageFormatProperties);
 335         return VK_SUCCESS;
 336 }
 337
 338 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceExtensionProperties (const char* pLayerName, deUint32* pPropertyCount, VkExtensionProperties* pProperties)
 339 {
 340         DE_UNREF(pLayerName);
 341         DE_UNREF(pPropertyCount);
 342         DE_UNREF(pProperties);
 343         return VK_SUCCESS;
 344 }
 345
 346 VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pPropertyCount, VkExtensionProperties* pProperties)
 347 {
 348         DE_UNREF(physicalDevice);
 349         DE_UNREF(pLayerName);
 350         DE_UNREF(pPropertyCount);
 351         DE_UNREF(pProperties);
 352         return VK_SUCCESS;
 353 }
 354
 355 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (deUint32* pPropertyCount, VkLayerProperties* pProperties)
 356 {
 357         DE_UNREF(pPropertyCount);
 358         DE_UNREF(pProperties);
 359         return VK_SUCCESS;
 360 }
 361
 362 VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkLayerProperties* pProperties)
 363 {
 364         DE_UNREF(physicalDevice);
 365         DE_UNREF(pPropertyCount);
 366         DE_UNREF(pProperties);
 367         return VK_SUCCESS;
 368 }
 369
 370 VKAPI_ATTR void VKAPI_CALL getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue)
 371 {
 372         DE_UNREF(device);
 373         DE_UNREF(queueFamilyIndex);
 374         DE_UNREF(queueIndex);
 375         DE_UNREF(pQueue);
 376 }
 377
 378 VKAPI_ATTR VkResult VKAPI_CALL queueSubmit (VkQueue queue, deUint32 submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
 379 {
 380         DE_UNREF(queue);
 381         DE_UNREF(submitCount);
 382         DE_UNREF(pSubmits);
 383         DE_UNREF(fence);
 384         return VK_SUCCESS;
 385 }
 386
 387 VKAPI_ATTR VkResult VKAPI_CALL queueWaitIdle (VkQueue queue)
 388 {
 389         DE_UNREF(queue);
 390         return VK_SUCCESS;
 391 }
 392
 393 VKAPI_ATTR VkResult VKAPI_CALL deviceWaitIdle (VkDevice device)
 394 {
 395         DE_UNREF(device);
 396         return VK_SUCCESS;
 397 }
 398
 399 VKAPI_ATTR void VKAPI_CALL unmapMemory (VkDevice device, VkDeviceMemory memory)
 400 {
 401         DE_UNREF(device);
 402         DE_UNREF(memory);
 403 }
 404
 405 VKAPI_ATTR VkResult VKAPI_CALL flushMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 406 {
 407         DE_UNREF(device);
 408         DE_UNREF(memoryRangeCount);
 409         DE_UNREF(pMemoryRanges);
 410         return VK_SUCCESS;
 411 }
 412
 413 VKAPI_ATTR VkResult VKAPI_CALL invalidateMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 414 {
 415         DE_UNREF(device);
 416         DE_UNREF(memoryRangeCount);
 417         DE_UNREF(pMemoryRanges);
 418         return VK_SUCCESS;
 419 }
 420
 421 VKAPI_ATTR void VKAPI_CALL getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
 422 {
 423         DE_UNREF(device);
 424         DE_UNREF(memory);
 425         DE_UNREF(pCommittedMemoryInBytes);
 426 }
 427
 428 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 429 {
 430         DE_UNREF(device);
 431         DE_UNREF(buffer);
 432         DE_UNREF(memory);
 433         DE_UNREF(memoryOffset);
 434         return VK_SUCCESS;
 435 }
 436
 437 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 438 {
 439         DE_UNREF(device);
 440         DE_UNREF(image);
 441         DE_UNREF(memory);
 442         DE_UNREF(memoryOffset);
 443         return VK_SUCCESS;
 444 }
 445
 446 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements (VkDevice device, VkImage image, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 447 {
 448         DE_UNREF(device);
 449         DE_UNREF(image);
 450         DE_UNREF(pSparseMemoryRequirementCount);
 451         DE_UNREF(pSparseMemoryRequirements);
 452 }
 453
 454 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, deUint32* pPropertyCount, VkSparseImageFormatProperties* pProperties)
 455 {
 456         DE_UNREF(physicalDevice);
 457         DE_UNREF(format);
 458         DE_UNREF(type);
 459         DE_UNREF(samples);
 460         DE_UNREF(usage);
 461         DE_UNREF(tiling);
 462         DE_UNREF(pPropertyCount);
 463         DE_UNREF(pProperties);
 464 }
 465
 466 VKAPI_ATTR VkResult VKAPI_CALL queueBindSparse (VkQueue queue, deUint32 bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
 467 {
 468         DE_UNREF(queue);
 469         DE_UNREF(bindInfoCount);
 470         DE_UNREF(pBindInfo);
 471         DE_UNREF(fence);
 472         return VK_SUCCESS;
 473 }
 474
 475 VKAPI_ATTR VkResult VKAPI_CALL resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences)
 476 {
 477         DE_UNREF(device);
 478         DE_UNREF(fenceCount);
 479         DE_UNREF(pFences);
 480         return VK_SUCCESS;
 481 }
 482
 483 VKAPI_ATTR VkResult VKAPI_CALL getFenceStatus (VkDevice device, VkFence fence)
 484 {
 485         DE_UNREF(device);
 486         DE_UNREF(fence);
 487         return VK_SUCCESS;
 488 }
 489
 490 VKAPI_ATTR VkResult VKAPI_CALL waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout)
 491 {
 492         DE_UNREF(device);
 493         DE_UNREF(fenceCount);
 494         DE_UNREF(pFences);
 495         DE_UNREF(waitAll);
 496         DE_UNREF(timeout);
 497         return VK_SUCCESS;
 498 }
 499
 500 VKAPI_ATTR VkResult VKAPI_CALL getEventStatus (VkDevice device, VkEvent event)
 501 {
 502         DE_UNREF(device);
 503         DE_UNREF(event);
 504         return VK_SUCCESS;
 505 }
 506
 507 VKAPI_ATTR VkResult VKAPI_CALL setEvent (VkDevice device, VkEvent event)
 508 {
 509         DE_UNREF(device);
 510         DE_UNREF(event);
 511         return VK_SUCCESS;
 512 }
 513
 514 VKAPI_ATTR VkResult VKAPI_CALL resetEvent (VkDevice device, VkEvent event)
 515 {
 516         DE_UNREF(device);
 517         DE_UNREF(event);
 518         return VK_SUCCESS;
 519 }
 520
 521 VKAPI_ATTR VkResult VKAPI_CALL getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
 522 {
 523         DE_UNREF(device);
 524         DE_UNREF(queryPool);
 525         DE_UNREF(firstQuery);
 526         DE_UNREF(queryCount);
 527         DE_UNREF(dataSize);
 528         DE_UNREF(pData);
 529         DE_UNREF(stride);
 530         DE_UNREF(flags);
 531         return VK_SUCCESS;
 532 }
 533
 534 VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
 535 {
 536         DE_UNREF(device);
 537         DE_UNREF(image);
 538         DE_UNREF(pSubresource);
 539         DE_UNREF(pLayout);
 540 }
 541
 542 VKAPI_ATTR VkResult VKAPI_CALL getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, deUintptr* pDataSize, void* pData)
 543 {
 544         DE_UNREF(device);
 545         DE_UNREF(pipelineCache);
 546         DE_UNREF(pDataSize);
 547         DE_UNREF(pData);
 548         return VK_SUCCESS;
 549 }
 550
 551 VKAPI_ATTR VkResult VKAPI_CALL mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches)
 552 {
 553         DE_UNREF(device);
 554         DE_UNREF(dstCache);
 555         DE_UNREF(srcCacheCount);
 556         DE_UNREF(pSrcCaches);
 557         return VK_SUCCESS;
 558 }
 559
 560 VKAPI_ATTR void VKAPI_CALL updateDescriptorSets (VkDevice device, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
 561 {
 562         DE_UNREF(device);
 563         DE_UNREF(descriptorWriteCount);
 564         DE_UNREF(pDescriptorWrites);
 565         DE_UNREF(descriptorCopyCount);
 566         DE_UNREF(pDescriptorCopies);
 567 }
 568
 569 VKAPI_ATTR void VKAPI_CALL getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
 570 {
 571         DE_UNREF(device);
 572         DE_UNREF(renderPass);
 573         DE_UNREF(pGranularity);
 574 }
 575
 576 VKAPI_ATTR VkResult VKAPI_CALL resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 577 {
 578         DE_UNREF(device);
 579         DE_UNREF(commandPool);
 580         DE_UNREF(flags);
 581         return VK_SUCCESS;
 582 }
 583
 584 VKAPI_ATTR VkResult VKAPI_CALL beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
 585 {
 586         DE_UNREF(commandBuffer);
 587         DE_UNREF(pBeginInfo);
 588         return VK_SUCCESS;
 589 }
 590
 591 VKAPI_ATTR VkResult VKAPI_CALL endCommandBuffer (VkCommandBuffer commandBuffer)
 592 {
 593         DE_UNREF(commandBuffer);
 594         return VK_SUCCESS;
 595 }
 596
 597 VKAPI_ATTR VkResult VKAPI_CALL resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 598 {
 599         DE_UNREF(commandBuffer);
 600         DE_UNREF(flags);
 601         return VK_SUCCESS;
 602 }
 603
 604 VKAPI_ATTR void VKAPI_CALL cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 605 {
 606         DE_UNREF(commandBuffer);
 607         DE_UNREF(pipelineBindPoint);
 608         DE_UNREF(pipeline);
 609 }
 610
 611 VKAPI_ATTR void VKAPI_CALL cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports)
 612 {
 613         DE_UNREF(commandBuffer);
 614         DE_UNREF(firstViewport);
 615         DE_UNREF(viewportCount);
 616         DE_UNREF(pViewports);
 617 }
 618
 619 VKAPI_ATTR void VKAPI_CALL cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors)
 620 {
 621         DE_UNREF(commandBuffer);
 622         DE_UNREF(firstScissor);
 623         DE_UNREF(scissorCount);
 624         DE_UNREF(pScissors);
 625 }
 626
 627 VKAPI_ATTR void VKAPI_CALL cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth)
 628 {
 629         DE_UNREF(commandBuffer);
 630         DE_UNREF(lineWidth);
 631 }
 632
 633 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 634 {
 635         DE_UNREF(commandBuffer);
 636         DE_UNREF(depthBiasConstantFactor);
 637         DE_UNREF(depthBiasClamp);
 638         DE_UNREF(depthBiasSlopeFactor);
 639 }
 640
 641 VKAPI_ATTR void VKAPI_CALL cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4])
 642 {
 643         DE_UNREF(commandBuffer);
 644         DE_UNREF(blendConstants);
 645 }
 646
 647 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 648 {
 649         DE_UNREF(commandBuffer);
 650         DE_UNREF(minDepthBounds);
 651         DE_UNREF(maxDepthBounds);
 652 }
 653
 654 VKAPI_ATTR void VKAPI_CALL cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 compareMask)
 655 {
 656         DE_UNREF(commandBuffer);
 657         DE_UNREF(faceMask);
 658         DE_UNREF(compareMask);
 659 }
 660
 661 VKAPI_ATTR void VKAPI_CALL cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 writeMask)
 662 {
 663         DE_UNREF(commandBuffer);
 664         DE_UNREF(faceMask);
 665         DE_UNREF(writeMask);
 666 }
 667
 668 VKAPI_ATTR void VKAPI_CALL cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 reference)
 669 {
 670         DE_UNREF(commandBuffer);
 671         DE_UNREF(faceMask);
 672         DE_UNREF(reference);
 673 }
 674
 675 VKAPI_ATTR void VKAPI_CALL cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 descriptorSetCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets)
 676 {
 677         DE_UNREF(commandBuffer);
 678         DE_UNREF(pipelineBindPoint);
 679         DE_UNREF(layout);
 680         DE_UNREF(firstSet);
 681         DE_UNREF(descriptorSetCount);
 682         DE_UNREF(pDescriptorSets);
 683         DE_UNREF(dynamicOffsetCount);
 684         DE_UNREF(pDynamicOffsets);
 685 }
 686
 687 VKAPI_ATTR void VKAPI_CALL cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 688 {
 689         DE_UNREF(commandBuffer);
 690         DE_UNREF(buffer);
 691         DE_UNREF(offset);
 692         DE_UNREF(indexType);
 693 }
 694
 695 VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
 696 {
 697         DE_UNREF(commandBuffer);
 698         DE_UNREF(firstBinding);
 699         DE_UNREF(bindingCount);
 700         DE_UNREF(pBuffers);
 701         DE_UNREF(pOffsets);
 702 }
 703
 704 VKAPI_ATTR void VKAPI_CALL cmdDraw (VkCommandBuffer commandBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance)
 705 {
 706         DE_UNREF(commandBuffer);
 707         DE_UNREF(vertexCount);
 708         DE_UNREF(instanceCount);
 709         DE_UNREF(firstVertex);
 710         DE_UNREF(firstInstance);
 711 }
 712
 713 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexed (VkCommandBuffer commandBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance)
 714 {
 715         DE_UNREF(commandBuffer);
 716         DE_UNREF(indexCount);
 717         DE_UNREF(instanceCount);
 718         DE_UNREF(firstIndex);
 719         DE_UNREF(vertexOffset);
 720         DE_UNREF(firstInstance);
 721 }
 722
 723 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride)
 724 {
 725         DE_UNREF(commandBuffer);
 726         DE_UNREF(buffer);
 727         DE_UNREF(offset);
 728         DE_UNREF(drawCount);
 729         DE_UNREF(stride);
 730 }
 731
 732 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride)
 733 {
 734         DE_UNREF(commandBuffer);
 735         DE_UNREF(buffer);
 736         DE_UNREF(offset);
 737         DE_UNREF(drawCount);
 738         DE_UNREF(stride);
 739 }
 740
 741 VKAPI_ATTR void VKAPI_CALL cmdDispatch (VkCommandBuffer commandBuffer, deUint32 x, deUint32 y, deUint32 z)
 742 {
 743         DE_UNREF(commandBuffer);
 744         DE_UNREF(x);
 745         DE_UNREF(y);
 746         DE_UNREF(z);
 747 }
 748
 749 VKAPI_ATTR void VKAPI_CALL cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 750 {
 751         DE_UNREF(commandBuffer);
 752         DE_UNREF(buffer);
 753         DE_UNREF(offset);
 754 }
 755
 756 VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferCopy* pRegions)
 757 {
 758         DE_UNREF(commandBuffer);
 759         DE_UNREF(srcBuffer);
 760         DE_UNREF(dstBuffer);
 761         DE_UNREF(regionCount);
 762         DE_UNREF(pRegions);
 763 }
 764
 765 VKAPI_ATTR void VKAPI_CALL cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageCopy* pRegions)
 766 {
 767         DE_UNREF(commandBuffer);
 768         DE_UNREF(srcImage);
 769         DE_UNREF(srcImageLayout);
 770         DE_UNREF(dstImage);
 771         DE_UNREF(dstImageLayout);
 772         DE_UNREF(regionCount);
 773         DE_UNREF(pRegions);
 774 }
 775
 776 VKAPI_ATTR void VKAPI_CALL cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkFilter filter)
 777 {
 778         DE_UNREF(commandBuffer);
 779         DE_UNREF(srcImage);
 780         DE_UNREF(srcImageLayout);
 781         DE_UNREF(dstImage);
 782         DE_UNREF(dstImageLayout);
 783         DE_UNREF(regionCount);
 784         DE_UNREF(pRegions);
 785         DE_UNREF(filter);
 786 }
 787
 788 VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 789 {
 790         DE_UNREF(commandBuffer);
 791         DE_UNREF(srcBuffer);
 792         DE_UNREF(dstImage);
 793         DE_UNREF(dstImageLayout);
 794         DE_UNREF(regionCount);
 795         DE_UNREF(pRegions);
 796 }
 797
 798 VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 799 {
 800         DE_UNREF(commandBuffer);
 801         DE_UNREF(srcImage);
 802         DE_UNREF(srcImageLayout);
 803         DE_UNREF(dstBuffer);
 804         DE_UNREF(regionCount);
 805         DE_UNREF(pRegions);
 806 }
 807
 808 VKAPI_ATTR void VKAPI_CALL cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const deUint32* pData)
 809 {
 810         DE_UNREF(commandBuffer);
 811         DE_UNREF(dstBuffer);
 812         DE_UNREF(dstOffset);
 813         DE_UNREF(dataSize);
 814         DE_UNREF(pData);
 815 }
 816
 817 VKAPI_ATTR void VKAPI_CALL cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, deUint32 data)
 818 {
 819         DE_UNREF(commandBuffer);
 820         DE_UNREF(dstBuffer);
 821         DE_UNREF(dstOffset);
 822         DE_UNREF(size);
 823         DE_UNREF(data);
 824 }
 825
 826 VKAPI_ATTR void VKAPI_CALL cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 827 {
 828         DE_UNREF(commandBuffer);
 829         DE_UNREF(image);
 830         DE_UNREF(imageLayout);
 831         DE_UNREF(pColor);
 832         DE_UNREF(rangeCount);
 833         DE_UNREF(pRanges);
 834 }
 835
 836 VKAPI_ATTR void VKAPI_CALL cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 837 {
 838         DE_UNREF(commandBuffer);
 839         DE_UNREF(image);
 840         DE_UNREF(imageLayout);
 841         DE_UNREF(pDepthStencil);
 842         DE_UNREF(rangeCount);
 843         DE_UNREF(pRanges);
 844 }
 845
 846 VKAPI_ATTR void VKAPI_CALL cmdClearAttachments (VkCommandBuffer commandBuffer, deUint32 attachmentCount, const VkClearAttachment* pAttachments, deUint32 rectCount, const VkClearRect* pRects)
 847 {
 848         DE_UNREF(commandBuffer);
 849         DE_UNREF(attachmentCount);
 850         DE_UNREF(pAttachments);
 851         DE_UNREF(rectCount);
 852         DE_UNREF(pRects);
 853 }
 854
 855 VKAPI_ATTR void VKAPI_CALL cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageResolve* pRegions)
 856 {
 857         DE_UNREF(commandBuffer);
 858         DE_UNREF(srcImage);
 859         DE_UNREF(srcImageLayout);
 860         DE_UNREF(dstImage);
 861         DE_UNREF(dstImageLayout);
 862         DE_UNREF(regionCount);
 863         DE_UNREF(pRegions);
 864 }
 865
 866 VKAPI_ATTR void VKAPI_CALL cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 867 {
 868         DE_UNREF(commandBuffer);
 869         DE_UNREF(event);
 870         DE_UNREF(stageMask);
 871 }
 872
 873 VKAPI_ATTR void VKAPI_CALL cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 874 {
 875         DE_UNREF(commandBuffer);
 876         DE_UNREF(event);
 877         DE_UNREF(stageMask);
 878 }
 879
 880 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)
 881 {
 882         DE_UNREF(commandBuffer);
 883         DE_UNREF(eventCount);
 884         DE_UNREF(pEvents);
 885         DE_UNREF(srcStageMask);
 886         DE_UNREF(dstStageMask);
 887         DE_UNREF(memoryBarrierCount);
 888         DE_UNREF(pMemoryBarriers);
 889         DE_UNREF(bufferMemoryBarrierCount);
 890         DE_UNREF(pBufferMemoryBarriers);
 891         DE_UNREF(imageMemoryBarrierCount);
 892         DE_UNREF(pImageMemoryBarriers);
 893 }
 894
 895 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)
 896 {
 897         DE_UNREF(commandBuffer);
 898         DE_UNREF(srcStageMask);
 899         DE_UNREF(dstStageMask);
 900         DE_UNREF(dependencyFlags);
 901         DE_UNREF(memoryBarrierCount);
 902         DE_UNREF(pMemoryBarriers);
 903         DE_UNREF(bufferMemoryBarrierCount);
 904         DE_UNREF(pBufferMemoryBarriers);
 905         DE_UNREF(imageMemoryBarrierCount);
 906         DE_UNREF(pImageMemoryBarriers);
 907 }
 908
 909 VKAPI_ATTR void VKAPI_CALL cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags)
 910 {
 911         DE_UNREF(commandBuffer);
 912         DE_UNREF(queryPool);
 913         DE_UNREF(query);
 914         DE_UNREF(flags);
 915 }
 916
 917 VKAPI_ATTR void VKAPI_CALL cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query)
 918 {
 919         DE_UNREF(commandBuffer);
 920         DE_UNREF(queryPool);
 921         DE_UNREF(query);
 922 }
 923
 924 VKAPI_ATTR void VKAPI_CALL cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount)
 925 {
 926         DE_UNREF(commandBuffer);
 927         DE_UNREF(queryPool);
 928         DE_UNREF(firstQuery);
 929         DE_UNREF(queryCount);
 930 }
 931
 932 VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query)
 933 {
 934         DE_UNREF(commandBuffer);
 935         DE_UNREF(pipelineStage);
 936         DE_UNREF(queryPool);
 937         DE_UNREF(query);
 938 }
 939
 940 VKAPI_ATTR void VKAPI_CALL cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 941 {
 942         DE_UNREF(commandBuffer);
 943         DE_UNREF(queryPool);
 944         DE_UNREF(firstQuery);
 945         DE_UNREF(queryCount);
 946         DE_UNREF(dstBuffer);
 947         DE_UNREF(dstOffset);
 948         DE_UNREF(stride);
 949         DE_UNREF(flags);
 950 }
 951
 952 VKAPI_ATTR void VKAPI_CALL cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 offset, deUint32 size, const void* pValues)
 953 {
 954         DE_UNREF(commandBuffer);
 955         DE_UNREF(layout);
 956         DE_UNREF(stageFlags);
 957         DE_UNREF(offset);
 958         DE_UNREF(size);
 959         DE_UNREF(pValues);
 960 }
 961
 962 VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
 963 {
 964         DE_UNREF(commandBuffer);
 965         DE_UNREF(pRenderPassBegin);
 966         DE_UNREF(contents);
 967 }
 968
 969 VKAPI_ATTR void VKAPI_CALL cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents)
 970 {
 971         DE_UNREF(commandBuffer);
 972         DE_UNREF(contents);
 973 }
 974
 975 VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass (VkCommandBuffer commandBuffer)
 976 {
 977         DE_UNREF(commandBuffer);
 978 }
 979
 980 VKAPI_ATTR void VKAPI_CALL cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers)
 981 {
 982         DE_UNREF(commandBuffer);
 983         DE_UNREF(commandBufferCount);
 984         DE_UNREF(pCommandBuffers);
 985 }
 986
 987 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported)
 988 {
 989         DE_UNREF(physicalDevice);
 990         DE_UNREF(queueFamilyIndex);
 991         DE_UNREF(surface);
 992         DE_UNREF(pSupported);
 993         return VK_SUCCESS;
 994 }
 995
 996 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
 997 {
 998         DE_UNREF(physicalDevice);
 999         DE_UNREF(surface);
1000         DE_UNREF(pSurfaceCapabilities);
1001         return VK_SUCCESS;
1002 }
1003
1004 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormatsKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, deUint32* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats)
1005 {
1006         DE_UNREF(physicalDevice);
1007         DE_UNREF(surface);
1008         DE_UNREF(pSurfaceFormatCount);
1009         DE_UNREF(pSurfaceFormats);
1010         return VK_SUCCESS;
1011 }
1012
1013 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, deUint32* pPresentModeCount, VkPresentModeKHR* pPresentModes)
1014 {
1015         DE_UNREF(physicalDevice);
1016         DE_UNREF(surface);
1017         DE_UNREF(pPresentModeCount);
1018         DE_UNREF(pPresentModes);
1019         return VK_SUCCESS;
1020 }
1021
1022 VKAPI_ATTR VkResult VKAPI_CALL getSwapchainImagesKHR (VkDevice device, VkSwapchainKHR swapchain, deUint32* pSwapchainImageCount, VkImage* pSwapchainImages)
1023 {
1024         DE_UNREF(device);
1025         DE_UNREF(swapchain);
1026         DE_UNREF(pSwapchainImageCount);
1027         DE_UNREF(pSwapchainImages);
1028         return VK_SUCCESS;
1029 }
1030
1031 VKAPI_ATTR VkResult VKAPI_CALL acquireNextImageKHR (VkDevice device, VkSwapchainKHR swapchain, deUint64 timeout, VkSemaphore semaphore, VkFence fence, deUint32* pImageIndex)
1032 {
1033         DE_UNREF(device);
1034         DE_UNREF(swapchain);
1035         DE_UNREF(timeout);
1036         DE_UNREF(semaphore);
1037         DE_UNREF(fence);
1038         DE_UNREF(pImageIndex);
1039         return VK_SUCCESS;
1040 }
1041
1042 VKAPI_ATTR VkResult VKAPI_CALL queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
1043 {
1044         DE_UNREF(queue);
1045         DE_UNREF(pPresentInfo);
1046         return VK_SUCCESS;
1047 }
1048
1049 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPropertiesKHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPropertiesKHR* pProperties)
1050 {
1051         DE_UNREF(physicalDevice);
1052         DE_UNREF(pPropertyCount);
1053         DE_UNREF(pProperties);
1054         return VK_SUCCESS;
1055 }
1056
1057 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlanePropertiesKHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties)
1058 {
1059         DE_UNREF(physicalDevice);
1060         DE_UNREF(pPropertyCount);
1061         DE_UNREF(pProperties);
1062         return VK_SUCCESS;
1063 }
1064
1065 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneSupportedDisplaysKHR (VkPhysicalDevice physicalDevice, deUint32 planeIndex, deUint32* pDisplayCount, VkDisplayKHR* pDisplays)
1066 {
1067         DE_UNREF(physicalDevice);
1068         DE_UNREF(planeIndex);
1069         DE_UNREF(pDisplayCount);
1070         DE_UNREF(pDisplays);
1071         return VK_SUCCESS;
1072 }
1073
1074 VKAPI_ATTR VkResult VKAPI_CALL getDisplayModePropertiesKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, deUint32* pPropertyCount, VkDisplayModePropertiesKHR* pProperties)
1075 {
1076         DE_UNREF(physicalDevice);
1077         DE_UNREF(display);
1078         DE_UNREF(pPropertyCount);
1079         DE_UNREF(pProperties);
1080         return VK_SUCCESS;
1081 }
1082
1083 VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, deUint32 planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities)
1084 {
1085         DE_UNREF(physicalDevice);
1086         DE_UNREF(mode);
1087         DE_UNREF(planeIndex);
1088         DE_UNREF(pCapabilities);
1089         return VK_SUCCESS;
1090 }
1091
1092 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXlibPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::XlibDisplayPtr dpy, pt::XlibVisualID visualID)
1093 {
1094         DE_UNREF(physicalDevice);
1095         DE_UNREF(queueFamilyIndex);
1096         DE_UNREF(dpy);
1097         DE_UNREF(visualID);
1098         return VK_SUCCESS;
1099 }
1100
1101 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXcbPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::XcbConnectionPtr connection, pt::XcbVisualid visual_id)
1102 {
1103         DE_UNREF(physicalDevice);
1104         DE_UNREF(queueFamilyIndex);
1105         DE_UNREF(connection);
1106         DE_UNREF(visual_id);
1107         return VK_SUCCESS;
1108 }
1109
1110 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWaylandPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::WaylandDisplayPtr display)
1111 {
1112         DE_UNREF(physicalDevice);
1113         DE_UNREF(queueFamilyIndex);
1114         DE_UNREF(display);
1115         return VK_SUCCESS;
1116 }
1117
1118 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceMirPresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, pt::MirConnectionPtr connection)
1119 {
1120         DE_UNREF(physicalDevice);
1121         DE_UNREF(queueFamilyIndex);
1122         DE_UNREF(connection);
1123         return VK_SUCCESS;
1124 }
1125
1126 VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex)
1127 {
1128         DE_UNREF(physicalDevice);
1129         DE_UNREF(queueFamilyIndex);
1130         return VK_SUCCESS;
1131 }
1132
1133 VKAPI_ATTR void VKAPI_CALL debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage)
1134 {
1135         DE_UNREF(instance);
1136         DE_UNREF(flags);
1137         DE_UNREF(objectType);
1138         DE_UNREF(object);
1139         DE_UNREF(location);
1140         DE_UNREF(messageCode);
1141         DE_UNREF(pLayerPrefix);
1142         DE_UNREF(pMessage);
1143 }
1144
1145 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectTagEXT (VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo)
1146 {
1147         DE_UNREF(device);
1148         DE_UNREF(pTagInfo);
1149         return VK_SUCCESS;
1150 }
1151
1152 VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectNameEXT (VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo)
1153 {
1154         DE_UNREF(device);
1155         DE_UNREF(pNameInfo);
1156         return VK_SUCCESS;
1157 }
1158
1159 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
1160 {
1161         DE_UNREF(commandBuffer);
1162         DE_UNREF(pMarkerInfo);
1163 }
1164
1165 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer)
1166 {
1167         DE_UNREF(commandBuffer);
1168 }
1169
1170 VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
1171 {
1172         DE_UNREF(commandBuffer);
1173         DE_UNREF(pMarkerInfo);
1174 }
1175
1176 static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
1177 {
1178         VK_NULL_FUNC_ENTRY(vkCreateInstance,                                            createInstance),
1179         VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr,                                       getInstanceProcAddr),
1180         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceExtensionProperties,      enumerateInstanceExtensionProperties),
1181         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceLayerProperties,          enumerateInstanceLayerProperties),
1182 };
1183
1184 static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
1185 {
1186         VK_NULL_FUNC_ENTRY(vkDestroyInstance,                                                                   destroyInstance),
1187         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDevices,                                                  enumeratePhysicalDevices),
1188         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures,                                                 getPhysicalDeviceFeatures),
1189         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties,                                 getPhysicalDeviceFormatProperties),
1190         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties,                    getPhysicalDeviceImageFormatProperties),
1191         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties,                                               getPhysicalDeviceProperties),
1192         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties,                    getPhysicalDeviceQueueFamilyProperties),
1193         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties,                                 getPhysicalDeviceMemoryProperties),
1194         VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr,                                                                 getDeviceProcAddr),
1195         VK_NULL_FUNC_ENTRY(vkCreateDevice,                                                                              createDevice),
1196         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceExtensionProperties,                                enumerateDeviceExtensionProperties),
1197         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceLayerProperties,                                    enumerateDeviceLayerProperties),
1198         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties,              getPhysicalDeviceSparseImageFormatProperties),
1199         VK_NULL_FUNC_ENTRY(vkDestroySurfaceKHR,                                                                 destroySurfaceKHR),
1200         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceSupportKHR,                                getPhysicalDeviceSurfaceSupportKHR),
1201         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilitiesKHR,                   getPhysicalDeviceSurfaceCapabilitiesKHR),
1202         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormatsKHR,                                getPhysicalDeviceSurfaceFormatsKHR),
1203         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModesKHR,                   getPhysicalDeviceSurfacePresentModesKHR),
1204         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPropertiesKHR,                             getPhysicalDeviceDisplayPropertiesKHR),
1205         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlanePropertiesKHR,                getPhysicalDeviceDisplayPlanePropertiesKHR),
1206         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneSupportedDisplaysKHR,                               getDisplayPlaneSupportedDisplaysKHR),
1207         VK_NULL_FUNC_ENTRY(vkGetDisplayModePropertiesKHR,                                               getDisplayModePropertiesKHR),
1208         VK_NULL_FUNC_ENTRY(vkCreateDisplayModeKHR,                                                              createDisplayModeKHR),
1209         VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilitiesKHR,                                    getDisplayPlaneCapabilitiesKHR),
1210         VK_NULL_FUNC_ENTRY(vkCreateDisplayPlaneSurfaceKHR,                                              createDisplayPlaneSurfaceKHR),
1211         VK_NULL_FUNC_ENTRY(vkCreateXlibSurfaceKHR,                                                              createXlibSurfaceKHR),
1212         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXlibPresentationSupportKHR,               getPhysicalDeviceXlibPresentationSupportKHR),
1213         VK_NULL_FUNC_ENTRY(vkCreateXcbSurfaceKHR,                                                               createXcbSurfaceKHR),
1214         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXcbPresentationSupportKHR,                getPhysicalDeviceXcbPresentationSupportKHR),
1215         VK_NULL_FUNC_ENTRY(vkCreateWaylandSurfaceKHR,                                                   createWaylandSurfaceKHR),
1216         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWaylandPresentationSupportKHR,    getPhysicalDeviceWaylandPresentationSupportKHR),
1217         VK_NULL_FUNC_ENTRY(vkCreateMirSurfaceKHR,                                                               createMirSurfaceKHR),
1218         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMirPresentationSupportKHR,                getPhysicalDeviceMirPresentationSupportKHR),
1219         VK_NULL_FUNC_ENTRY(vkCreateAndroidSurfaceKHR,                                                   createAndroidSurfaceKHR),
1220         VK_NULL_FUNC_ENTRY(vkCreateWin32SurfaceKHR,                                                             createWin32SurfaceKHR),
1221         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWin32PresentationSupportKHR,              getPhysicalDeviceWin32PresentationSupportKHR),
1222         VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT,                                              createDebugReportCallbackEXT),
1223         VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT,                                             destroyDebugReportCallbackEXT),
1224         VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT,                                                             debugReportMessageEXT),
1225 };
1226
1227 static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
1228 {
1229         VK_NULL_FUNC_ENTRY(vkDestroyDevice,                                             destroyDevice),
1230         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue,                                    getDeviceQueue),
1231         VK_NULL_FUNC_ENTRY(vkQueueSubmit,                                               queueSubmit),
1232         VK_NULL_FUNC_ENTRY(vkQueueWaitIdle,                                             queueWaitIdle),
1233         VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle,                                    deviceWaitIdle),
1234         VK_NULL_FUNC_ENTRY(vkAllocateMemory,                                    allocateMemory),
1235         VK_NULL_FUNC_ENTRY(vkFreeMemory,                                                freeMemory),
1236         VK_NULL_FUNC_ENTRY(vkMapMemory,                                                 mapMemory),
1237         VK_NULL_FUNC_ENTRY(vkUnmapMemory,                                               unmapMemory),
1238         VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges,                   flushMappedMemoryRanges),
1239         VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges,              invalidateMappedMemoryRanges),
1240         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment,                 getDeviceMemoryCommitment),
1241         VK_NULL_FUNC_ENTRY(vkBindBufferMemory,                                  bindBufferMemory),
1242         VK_NULL_FUNC_ENTRY(vkBindImageMemory,                                   bindImageMemory),
1243         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements,               getBufferMemoryRequirements),
1244         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements,                getImageMemoryRequirements),
1245         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements,  getImageSparseMemoryRequirements),
1246         VK_NULL_FUNC_ENTRY(vkQueueBindSparse,                                   queueBindSparse),
1247         VK_NULL_FUNC_ENTRY(vkCreateFence,                                               createFence),
1248         VK_NULL_FUNC_ENTRY(vkDestroyFence,                                              destroyFence),
1249         VK_NULL_FUNC_ENTRY(vkResetFences,                                               resetFences),
1250         VK_NULL_FUNC_ENTRY(vkGetFenceStatus,                                    getFenceStatus),
1251         VK_NULL_FUNC_ENTRY(vkWaitForFences,                                             waitForFences),
1252         VK_NULL_FUNC_ENTRY(vkCreateSemaphore,                                   createSemaphore),
1253         VK_NULL_FUNC_ENTRY(vkDestroySemaphore,                                  destroySemaphore),
1254         VK_NULL_FUNC_ENTRY(vkCreateEvent,                                               createEvent),
1255         VK_NULL_FUNC_ENTRY(vkDestroyEvent,                                              destroyEvent),
1256         VK_NULL_FUNC_ENTRY(vkGetEventStatus,                                    getEventStatus),
1257         VK_NULL_FUNC_ENTRY(vkSetEvent,                                                  setEvent),
1258         VK_NULL_FUNC_ENTRY(vkResetEvent,                                                resetEvent),
1259         VK_NULL_FUNC_ENTRY(vkCreateQueryPool,                                   createQueryPool),
1260         VK_NULL_FUNC_ENTRY(vkDestroyQueryPool,                                  destroyQueryPool),
1261         VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults,                               getQueryPoolResults),
1262         VK_NULL_FUNC_ENTRY(vkCreateBuffer,                                              createBuffer),
1263         VK_NULL_FUNC_ENTRY(vkDestroyBuffer,                                             destroyBuffer),
1264         VK_NULL_FUNC_ENTRY(vkCreateBufferView,                                  createBufferView),
1265         VK_NULL_FUNC_ENTRY(vkDestroyBufferView,                                 destroyBufferView),
1266         VK_NULL_FUNC_ENTRY(vkCreateImage,                                               createImage),
1267         VK_NULL_FUNC_ENTRY(vkDestroyImage,                                              destroyImage),
1268         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout,                 getImageSubresourceLayout),
1269         VK_NULL_FUNC_ENTRY(vkCreateImageView,                                   createImageView),
1270         VK_NULL_FUNC_ENTRY(vkDestroyImageView,                                  destroyImageView),
1271         VK_NULL_FUNC_ENTRY(vkCreateShaderModule,                                createShaderModule),
1272         VK_NULL_FUNC_ENTRY(vkDestroyShaderModule,                               destroyShaderModule),
1273         VK_NULL_FUNC_ENTRY(vkCreatePipelineCache,                               createPipelineCache),
1274         VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache,                              destroyPipelineCache),
1275         VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData,                              getPipelineCacheData),
1276         VK_NULL_FUNC_ENTRY(vkMergePipelineCaches,                               mergePipelineCaches),
1277         VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines,                   createGraphicsPipelines),
1278         VK_NULL_FUNC_ENTRY(vkCreateComputePipelines,                    createComputePipelines),
1279         VK_NULL_FUNC_ENTRY(vkDestroyPipeline,                                   destroyPipeline),
1280         VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout,                              createPipelineLayout),
1281         VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout,                             destroyPipelineLayout),
1282         VK_NULL_FUNC_ENTRY(vkCreateSampler,                                             createSampler),
1283         VK_NULL_FUNC_ENTRY(vkDestroySampler,                                    destroySampler),
1284         VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout,                 createDescriptorSetLayout),
1285         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout,                destroyDescriptorSetLayout),
1286         VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool,                              createDescriptorPool),
1287         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool,                             destroyDescriptorPool),
1288         VK_NULL_FUNC_ENTRY(vkResetDescriptorPool,                               resetDescriptorPool),
1289         VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets,                    allocateDescriptorSets),
1290         VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets,                                freeDescriptorSets),
1291         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets,                              updateDescriptorSets),
1292         VK_NULL_FUNC_ENTRY(vkCreateFramebuffer,                                 createFramebuffer),
1293         VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer,                                destroyFramebuffer),
1294         VK_NULL_FUNC_ENTRY(vkCreateRenderPass,                                  createRenderPass),
1295         VK_NULL_FUNC_ENTRY(vkDestroyRenderPass,                                 destroyRenderPass),
1296         VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity,                  getRenderAreaGranularity),
1297         VK_NULL_FUNC_ENTRY(vkCreateCommandPool,                                 createCommandPool),
1298         VK_NULL_FUNC_ENTRY(vkDestroyCommandPool,                                destroyCommandPool),
1299         VK_NULL_FUNC_ENTRY(vkResetCommandPool,                                  resetCommandPool),
1300         VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers,                    allocateCommandBuffers),
1301         VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers,                                freeCommandBuffers),
1302         VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer,                                beginCommandBuffer),
1303         VK_NULL_FUNC_ENTRY(vkEndCommandBuffer,                                  endCommandBuffer),
1304         VK_NULL_FUNC_ENTRY(vkResetCommandBuffer,                                resetCommandBuffer),
1305         VK_NULL_FUNC_ENTRY(vkCmdBindPipeline,                                   cmdBindPipeline),
1306         VK_NULL_FUNC_ENTRY(vkCmdSetViewport,                                    cmdSetViewport),
1307         VK_NULL_FUNC_ENTRY(vkCmdSetScissor,                                             cmdSetScissor),
1308         VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth,                                   cmdSetLineWidth),
1309         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias,                                   cmdSetDepthBias),
1310         VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants,                              cmdSetBlendConstants),
1311         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds,                                 cmdSetDepthBounds),
1312         VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask,                  cmdSetStencilCompareMask),
1313         VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask,                    cmdSetStencilWriteMask),
1314         VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference,                    cmdSetStencilReference),
1315         VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets,                             cmdBindDescriptorSets),
1316         VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer,                                cmdBindIndexBuffer),
1317         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers,                              cmdBindVertexBuffers),
1318         VK_NULL_FUNC_ENTRY(vkCmdDraw,                                                   cmdDraw),
1319         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed,                                    cmdDrawIndexed),
1320         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect,                                   cmdDrawIndirect),
1321         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect,                    cmdDrawIndexedIndirect),
1322         VK_NULL_FUNC_ENTRY(vkCmdDispatch,                                               cmdDispatch),
1323         VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect,                               cmdDispatchIndirect),
1324         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer,                                             cmdCopyBuffer),
1325         VK_NULL_FUNC_ENTRY(vkCmdCopyImage,                                              cmdCopyImage),
1326         VK_NULL_FUNC_ENTRY(vkCmdBlitImage,                                              cmdBlitImage),
1327         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage,                              cmdCopyBufferToImage),
1328         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer,                              cmdCopyImageToBuffer),
1329         VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer,                                   cmdUpdateBuffer),
1330         VK_NULL_FUNC_ENTRY(vkCmdFillBuffer,                                             cmdFillBuffer),
1331         VK_NULL_FUNC_ENTRY(vkCmdClearColorImage,                                cmdClearColorImage),
1332         VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage,                 cmdClearDepthStencilImage),
1333         VK_NULL_FUNC_ENTRY(vkCmdClearAttachments,                               cmdClearAttachments),
1334         VK_NULL_FUNC_ENTRY(vkCmdResolveImage,                                   cmdResolveImage),
1335         VK_NULL_FUNC_ENTRY(vkCmdSetEvent,                                               cmdSetEvent),
1336         VK_NULL_FUNC_ENTRY(vkCmdResetEvent,                                             cmdResetEvent),
1337         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents,                                             cmdWaitEvents),
1338         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier,                                cmdPipelineBarrier),
1339         VK_NULL_FUNC_ENTRY(vkCmdBeginQuery,                                             cmdBeginQuery),
1340         VK_NULL_FUNC_ENTRY(vkCmdEndQuery,                                               cmdEndQuery),
1341         VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool,                                 cmdResetQueryPool),
1342         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp,                                 cmdWriteTimestamp),
1343         VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults,                   cmdCopyQueryPoolResults),
1344         VK_NULL_FUNC_ENTRY(vkCmdPushConstants,                                  cmdPushConstants),
1345         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass,                                cmdBeginRenderPass),
1346         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass,                                    cmdNextSubpass),
1347         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass,                                  cmdEndRenderPass),
1348         VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands,                                cmdExecuteCommands),
1349         VK_NULL_FUNC_ENTRY(vkCreateSwapchainKHR,                                createSwapchainKHR),
1350         VK_NULL_FUNC_ENTRY(vkDestroySwapchainKHR,                               destroySwapchainKHR),
1351         VK_NULL_FUNC_ENTRY(vkGetSwapchainImagesKHR,                             getSwapchainImagesKHR),
1352         VK_NULL_FUNC_ENTRY(vkAcquireNextImageKHR,                               acquireNextImageKHR),
1353         VK_NULL_FUNC_ENTRY(vkQueuePresentKHR,                                   queuePresentKHR),
1354         VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR,                 createSharedSwapchainsKHR),
1355         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectTagEXT,                debugMarkerSetObjectTagEXT),
1356         VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectNameEXT,               debugMarkerSetObjectNameEXT),
1357         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerBeginEXT,                    cmdDebugMarkerBeginEXT),
1358         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerEndEXT,                              cmdDebugMarkerEndEXT),
1359         VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerInsertEXT,                   cmdDebugMarkerInsertEXT),
1360 };
1361