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