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