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 VkResult createInstance (const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
   5 {
   6         VK_NULL_RETURN(*pInstance = reinterpret_cast<VkInstance>(new Instance(pCreateInfo)));
   7 }
   8
   9 VkResult createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
  10 {
  11         VK_NULL_RETURN(*pDevice = reinterpret_cast<VkDevice>(new Device(physicalDevice, pCreateInfo)));
  12 }
  13
  14 VkResult allocMemory (VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem)
  15 {
  16         VK_NULL_RETURN(*pMem = VkDeviceMemory((deUint64)(deUintptr)new DeviceMemory(device, pAllocInfo)));
  17 }
  18
  19 VkResult createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
  20 {
  21         VK_NULL_RETURN(*pFence = VkFence((deUint64)(deUintptr)new Fence(device, pCreateInfo)));
  22 }
  23
  24 VkResult createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore)
  25 {
  26         VK_NULL_RETURN(*pSemaphore = VkSemaphore((deUint64)(deUintptr)new Semaphore(device, pCreateInfo)));
  27 }
  28
  29 VkResult createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent)
  30 {
  31         VK_NULL_RETURN(*pEvent = VkEvent((deUint64)(deUintptr)new Event(device, pCreateInfo)));
  32 }
  33
  34 VkResult createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool)
  35 {
  36         VK_NULL_RETURN(*pQueryPool = VkQueryPool((deUint64)(deUintptr)new QueryPool(device, pCreateInfo)));
  37 }
  38
  39 VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer)
  40 {
  41         VK_NULL_RETURN(*pBuffer = VkBuffer((deUint64)(deUintptr)new Buffer(device, pCreateInfo)));
  42 }
  43
  44 VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
  45 {
  46         VK_NULL_RETURN(*pView = VkBufferView((deUint64)(deUintptr)new BufferView(device, pCreateInfo)));
  47 }
  48
  49 VkResult createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
  50 {
  51         VK_NULL_RETURN(*pImage = VkImage((deUint64)(deUintptr)new Image(device, pCreateInfo)));
  52 }
  53
  54 VkResult createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
  55 {
  56         VK_NULL_RETURN(*pView = VkImageView((deUint64)(deUintptr)new ImageView(device, pCreateInfo)));
  57 }
  58
  59 VkResult createAttachmentView (VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView)
  60 {
  61         VK_NULL_RETURN(*pView = VkAttachmentView((deUint64)(deUintptr)new AttachmentView(device, pCreateInfo)));
  62 }
  63
  64 VkResult createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule)
  65 {
  66         VK_NULL_RETURN(*pShaderModule = VkShaderModule((deUint64)(deUintptr)new ShaderModule(device, pCreateInfo)));
  67 }
  68
  69 VkResult createShader (VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader)
  70 {
  71         VK_NULL_RETURN(*pShader = VkShader((deUint64)(deUintptr)new Shader(device, pCreateInfo)));
  72 }
  73
  74 VkResult createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache)
  75 {
  76         VK_NULL_RETURN(*pPipelineCache = VkPipelineCache((deUint64)(deUintptr)new PipelineCache(device, pCreateInfo)));
  77 }
  78
  79 VkResult createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
  80 {
  81         VK_NULL_RETURN(*pPipelineLayout = VkPipelineLayout((deUint64)(deUintptr)new PipelineLayout(device, pCreateInfo)));
  82 }
  83
  84 VkResult createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
  85 {
  86         VK_NULL_RETURN(*pSampler = VkSampler((deUint64)(deUintptr)new Sampler(device, pCreateInfo)));
  87 }
  88
  89 VkResult createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
  90 {
  91         VK_NULL_RETURN(*pSetLayout = VkDescriptorSetLayout((deUint64)(deUintptr)new DescriptorSetLayout(device, pCreateInfo)));
  92 }
  93
  94 VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolUsage poolUsage, deUint32 maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
  95 {
  96         VK_NULL_RETURN(*pDescriptorPool = VkDescriptorPool((deUint64)(deUintptr)new DescriptorPool(device, poolUsage, maxSets, pCreateInfo)));
  97 }
  98
  99 VkResult createDynamicViewportState (VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState)
 100 {
 101         VK_NULL_RETURN(*pState = VkDynamicViewportState((deUint64)(deUintptr)new DynamicViewportState(device, pCreateInfo)));
 102 }
 103
 104 VkResult createDynamicRasterState (VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState)
 105 {
 106         VK_NULL_RETURN(*pState = VkDynamicRasterState((deUint64)(deUintptr)new DynamicRasterState(device, pCreateInfo)));
 107 }
 108
 109 VkResult createDynamicColorBlendState (VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState)
 110 {
 111         VK_NULL_RETURN(*pState = VkDynamicColorBlendState((deUint64)(deUintptr)new DynamicColorBlendState(device, pCreateInfo)));
 112 }
 113
 114 VkResult createDynamicDepthStencilState (VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState)
 115 {
 116         VK_NULL_RETURN(*pState = VkDynamicDepthStencilState((deUint64)(deUintptr)new DynamicDepthStencilState(device, pCreateInfo)));
 117 }
 118
 119 VkResult createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
 120 {
 121         VK_NULL_RETURN(*pFramebuffer = VkFramebuffer((deUint64)(deUintptr)new Framebuffer(device, pCreateInfo)));
 122 }
 123
 124 VkResult createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
 125 {
 126         VK_NULL_RETURN(*pRenderPass = VkRenderPass((deUint64)(deUintptr)new RenderPass(device, pCreateInfo)));
 127 }
 128
 129 VkResult createCommandPool (VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool)
 130 {
 131         VK_NULL_RETURN(*pCmdPool = VkCmdPool((deUint64)(deUintptr)new CmdPool(device, pCreateInfo)));
 132 }
 133
 134 VkResult createCommandBuffer (VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
 135 {
 136         VK_NULL_RETURN(*pCmdBuffer = reinterpret_cast<VkCmdBuffer>(new CmdBuffer(device, pCreateInfo)));
 137 }
 138
 139 VkResult destroyInstance (VkInstance instance)
 140 {
 141         VK_NULL_RETURN(delete reinterpret_cast<Instance*>(instance));
 142 }
 143
 144 VkResult destroyDevice (VkDevice device)
 145 {
 146         VK_NULL_RETURN(delete reinterpret_cast<Device*>(device));
 147 }
 148
 149 VkResult freeMemory (VkDevice device, VkDeviceMemory mem)
 150 {
 151         DE_UNREF(device);
 152         VK_NULL_RETURN(delete reinterpret_cast<DeviceMemory*>((deUintptr)mem.getInternal()));
 153 }
 154
 155 VkResult destroyFence (VkDevice device, VkFence fence)
 156 {
 157         DE_UNREF(device);
 158         VK_NULL_RETURN(delete reinterpret_cast<Fence*>((deUintptr)fence.getInternal()));
 159 }
 160
 161 VkResult destroySemaphore (VkDevice device, VkSemaphore semaphore)
 162 {
 163         DE_UNREF(device);
 164         VK_NULL_RETURN(delete reinterpret_cast<Semaphore*>((deUintptr)semaphore.getInternal()));
 165 }
 166
 167 VkResult destroyEvent (VkDevice device, VkEvent event)
 168 {
 169         DE_UNREF(device);
 170         VK_NULL_RETURN(delete reinterpret_cast<Event*>((deUintptr)event.getInternal()));
 171 }
 172
 173 VkResult destroyQueryPool (VkDevice device, VkQueryPool queryPool)
 174 {
 175         DE_UNREF(device);
 176         VK_NULL_RETURN(delete reinterpret_cast<QueryPool*>((deUintptr)queryPool.getInternal()));
 177 }
 178
 179 VkResult destroyBuffer (VkDevice device, VkBuffer buffer)
 180 {
 181         DE_UNREF(device);
 182         VK_NULL_RETURN(delete reinterpret_cast<Buffer*>((deUintptr)buffer.getInternal()));
 183 }
 184
 185 VkResult destroyBufferView (VkDevice device, VkBufferView bufferView)
 186 {
 187         DE_UNREF(device);
 188         VK_NULL_RETURN(delete reinterpret_cast<BufferView*>((deUintptr)bufferView.getInternal()));
 189 }
 190
 191 VkResult destroyImage (VkDevice device, VkImage image)
 192 {
 193         DE_UNREF(device);
 194         VK_NULL_RETURN(delete reinterpret_cast<Image*>((deUintptr)image.getInternal()));
 195 }
 196
 197 VkResult destroyImageView (VkDevice device, VkImageView imageView)
 198 {
 199         DE_UNREF(device);
 200         VK_NULL_RETURN(delete reinterpret_cast<ImageView*>((deUintptr)imageView.getInternal()));
 201 }
 202
 203 VkResult destroyAttachmentView (VkDevice device, VkAttachmentView attachmentView)
 204 {
 205         DE_UNREF(device);
 206         VK_NULL_RETURN(delete reinterpret_cast<AttachmentView*>((deUintptr)attachmentView.getInternal()));
 207 }
 208
 209 VkResult destroyShaderModule (VkDevice device, VkShaderModule shaderModule)
 210 {
 211         DE_UNREF(device);
 212         VK_NULL_RETURN(delete reinterpret_cast<ShaderModule*>((deUintptr)shaderModule.getInternal()));
 213 }
 214
 215 VkResult destroyShader (VkDevice device, VkShader shader)
 216 {
 217         DE_UNREF(device);
 218         VK_NULL_RETURN(delete reinterpret_cast<Shader*>((deUintptr)shader.getInternal()));
 219 }
 220
 221 VkResult destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache)
 222 {
 223         DE_UNREF(device);
 224         VK_NULL_RETURN(delete reinterpret_cast<PipelineCache*>((deUintptr)pipelineCache.getInternal()));
 225 }
 226
 227 VkResult destroyPipeline (VkDevice device, VkPipeline pipeline)
 228 {
 229         DE_UNREF(device);
 230         VK_NULL_RETURN(delete reinterpret_cast<Pipeline*>((deUintptr)pipeline.getInternal()));
 231 }
 232
 233 VkResult destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout)
 234 {
 235         DE_UNREF(device);
 236         VK_NULL_RETURN(delete reinterpret_cast<PipelineLayout*>((deUintptr)pipelineLayout.getInternal()));
 237 }
 238
 239 VkResult destroySampler (VkDevice device, VkSampler sampler)
 240 {
 241         DE_UNREF(device);
 242         VK_NULL_RETURN(delete reinterpret_cast<Sampler*>((deUintptr)sampler.getInternal()));
 243 }
 244
 245 VkResult destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
 246 {
 247         DE_UNREF(device);
 248         VK_NULL_RETURN(delete reinterpret_cast<DescriptorSetLayout*>((deUintptr)descriptorSetLayout.getInternal()));
 249 }
 250
 251 VkResult destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool)
 252 {
 253         DE_UNREF(device);
 254         VK_NULL_RETURN(delete reinterpret_cast<DescriptorPool*>((deUintptr)descriptorPool.getInternal()));
 255 }
 256
 257 VkResult destroyDynamicViewportState (VkDevice device, VkDynamicViewportState dynamicViewportState)
 258 {
 259         DE_UNREF(device);
 260         VK_NULL_RETURN(delete reinterpret_cast<DynamicViewportState*>((deUintptr)dynamicViewportState.getInternal()));
 261 }
 262
 263 VkResult destroyDynamicRasterState (VkDevice device, VkDynamicRasterState dynamicRasterState)
 264 {
 265         DE_UNREF(device);
 266         VK_NULL_RETURN(delete reinterpret_cast<DynamicRasterState*>((deUintptr)dynamicRasterState.getInternal()));
 267 }
 268
 269 VkResult destroyDynamicColorBlendState (VkDevice device, VkDynamicColorBlendState dynamicColorBlendState)
 270 {
 271         DE_UNREF(device);
 272         VK_NULL_RETURN(delete reinterpret_cast<DynamicColorBlendState*>((deUintptr)dynamicColorBlendState.getInternal()));
 273 }
 274
 275 VkResult destroyDynamicDepthStencilState (VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState)
 276 {
 277         DE_UNREF(device);
 278         VK_NULL_RETURN(delete reinterpret_cast<DynamicDepthStencilState*>((deUintptr)dynamicDepthStencilState.getInternal()));
 279 }
 280
 281 VkResult destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer)
 282 {
 283         DE_UNREF(device);
 284         VK_NULL_RETURN(delete reinterpret_cast<Framebuffer*>((deUintptr)framebuffer.getInternal()));
 285 }
 286
 287 VkResult destroyRenderPass (VkDevice device, VkRenderPass renderPass)
 288 {
 289         DE_UNREF(device);
 290         VK_NULL_RETURN(delete reinterpret_cast<RenderPass*>((deUintptr)renderPass.getInternal()));
 291 }
 292
 293 VkResult destroyCommandPool (VkDevice device, VkCmdPool cmdPool)
 294 {
 295         DE_UNREF(device);
 296         VK_NULL_RETURN(delete reinterpret_cast<CmdPool*>((deUintptr)cmdPool.getInternal()));
 297 }
 298
 299 VkResult destroyCommandBuffer (VkDevice device, VkCmdBuffer commandBuffer)
 300 {
 301         DE_UNREF(device);
 302         VK_NULL_RETURN(delete reinterpret_cast<CmdBuffer*>(commandBuffer));
 303 }
 304
 305 VkResult getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
 306 {
 307         DE_UNREF(physicalDevice);
 308         DE_UNREF(pFeatures);
 309         return VK_SUCCESS;
 310 }
 311
 312 VkResult getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
 313 {
 314         DE_UNREF(physicalDevice);
 315         DE_UNREF(format);
 316         DE_UNREF(pFormatProperties);
 317         return VK_SUCCESS;
 318 }
 319
 320 VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties)
 321 {
 322         DE_UNREF(physicalDevice);
 323         DE_UNREF(format);
 324         DE_UNREF(type);
 325         DE_UNREF(tiling);
 326         DE_UNREF(usage);
 327         DE_UNREF(pImageFormatProperties);
 328         return VK_SUCCESS;
 329 }
 330
 331 VkResult getPhysicalDeviceLimits (VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits)
 332 {
 333         DE_UNREF(physicalDevice);
 334         DE_UNREF(pLimits);
 335         return VK_SUCCESS;
 336 }
 337
 338 VkResult getGlobalExtensionProperties (const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties)
 339 {
 340         DE_UNREF(pLayerName);
 341         DE_UNREF(pCount);
 342         DE_UNREF(pProperties);
 343         return VK_SUCCESS;
 344 }
 345
 346 VkResult getPhysicalDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pCount, VkExtensionProperties* pProperties)
 347 {
 348         DE_UNREF(physicalDevice);
 349         DE_UNREF(pLayerName);
 350         DE_UNREF(pCount);
 351         DE_UNREF(pProperties);
 352         return VK_SUCCESS;
 353 }
 354
 355 VkResult getGlobalLayerProperties (deUint32* pCount, VkLayerProperties* pProperties)
 356 {
 357         DE_UNREF(pCount);
 358         DE_UNREF(pProperties);
 359         return VK_SUCCESS;
 360 }
 361
 362 VkResult getPhysicalDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pCount, VkLayerProperties* pProperties)
 363 {
 364         DE_UNREF(physicalDevice);
 365         DE_UNREF(pCount);
 366         DE_UNREF(pProperties);
 367         return VK_SUCCESS;
 368 }
 369
 370 VkResult getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue)
 371 {
 372         DE_UNREF(device);
 373         DE_UNREF(queueFamilyIndex);
 374         DE_UNREF(queueIndex);
 375         DE_UNREF(pQueue);
 376         return VK_SUCCESS;
 377 }
 378
 379 VkResult queueSubmit (VkQueue queue, deUint32 cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence)
 380 {
 381         DE_UNREF(queue);
 382         DE_UNREF(cmdBufferCount);
 383         DE_UNREF(pCmdBuffers);
 384         DE_UNREF(fence);
 385         return VK_SUCCESS;
 386 }
 387
 388 VkResult queueWaitIdle (VkQueue queue)
 389 {
 390         DE_UNREF(queue);
 391         return VK_SUCCESS;
 392 }
 393
 394 VkResult deviceWaitIdle (VkDevice device)
 395 {
 396         DE_UNREF(device);
 397         return VK_SUCCESS;
 398 }
 399
 400 VkResult unmapMemory (VkDevice device, VkDeviceMemory mem)
 401 {
 402         DE_UNREF(device);
 403         DE_UNREF(mem);
 404         return VK_SUCCESS;
 405 }
 406
 407 VkResult flushMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges)
 408 {
 409         DE_UNREF(device);
 410         DE_UNREF(memRangeCount);
 411         DE_UNREF(pMemRanges);
 412         return VK_SUCCESS;
 413 }
 414
 415 VkResult invalidateMappedMemoryRanges (VkDevice device, deUint32 memRangeCount, const VkMappedMemoryRange* pMemRanges)
 416 {
 417         DE_UNREF(device);
 418         DE_UNREF(memRangeCount);
 419         DE_UNREF(pMemRanges);
 420         return VK_SUCCESS;
 421 }
 422
 423 VkResult getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
 424 {
 425         DE_UNREF(device);
 426         DE_UNREF(memory);
 427         DE_UNREF(pCommittedMemoryInBytes);
 428         return VK_SUCCESS;
 429 }
 430
 431 VkResult bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset)
 432 {
 433         DE_UNREF(device);
 434         DE_UNREF(buffer);
 435         DE_UNREF(mem);
 436         DE_UNREF(memOffset);
 437         return VK_SUCCESS;
 438 }
 439
 440 VkResult bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset)
 441 {
 442         DE_UNREF(device);
 443         DE_UNREF(image);
 444         DE_UNREF(mem);
 445         DE_UNREF(memOffset);
 446         return VK_SUCCESS;
 447 }
 448
 449 VkResult getImageSparseMemoryRequirements (VkDevice device, VkImage image, deUint32* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 450 {
 451         DE_UNREF(device);
 452         DE_UNREF(image);
 453         DE_UNREF(pNumRequirements);
 454         DE_UNREF(pSparseMemoryRequirements);
 455         return VK_SUCCESS;
 456 }
 457
 458 VkResult getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, deUint32 samples, VkImageUsageFlags usage, VkImageTiling tiling, deUint32* pNumProperties, VkSparseImageFormatProperties* pProperties)
 459 {
 460         DE_UNREF(physicalDevice);
 461         DE_UNREF(format);
 462         DE_UNREF(type);
 463         DE_UNREF(samples);
 464         DE_UNREF(usage);
 465         DE_UNREF(tiling);
 466         DE_UNREF(pNumProperties);
 467         DE_UNREF(pProperties);
 468         return VK_SUCCESS;
 469 }
 470
 471 VkResult queueBindSparseBufferMemory (VkQueue queue, VkBuffer buffer, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo)
 472 {
 473         DE_UNREF(queue);
 474         DE_UNREF(buffer);
 475         DE_UNREF(numBindings);
 476         DE_UNREF(pBindInfo);
 477         return VK_SUCCESS;
 478 }
 479
 480 VkResult queueBindSparseImageOpaqueMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseMemoryBindInfo* pBindInfo)
 481 {
 482         DE_UNREF(queue);
 483         DE_UNREF(image);
 484         DE_UNREF(numBindings);
 485         DE_UNREF(pBindInfo);
 486         return VK_SUCCESS;
 487 }
 488
 489 VkResult queueBindSparseImageMemory (VkQueue queue, VkImage image, deUint32 numBindings, const VkSparseImageMemoryBindInfo* pBindInfo)
 490 {
 491         DE_UNREF(queue);
 492         DE_UNREF(image);
 493         DE_UNREF(numBindings);
 494         DE_UNREF(pBindInfo);
 495         return VK_SUCCESS;
 496 }
 497
 498 VkResult resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences)
 499 {
 500         DE_UNREF(device);
 501         DE_UNREF(fenceCount);
 502         DE_UNREF(pFences);
 503         return VK_SUCCESS;
 504 }
 505
 506 VkResult getFenceStatus (VkDevice device, VkFence fence)
 507 {
 508         DE_UNREF(device);
 509         DE_UNREF(fence);
 510         return VK_SUCCESS;
 511 }
 512
 513 VkResult waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout)
 514 {
 515         DE_UNREF(device);
 516         DE_UNREF(fenceCount);
 517         DE_UNREF(pFences);
 518         DE_UNREF(waitAll);
 519         DE_UNREF(timeout);
 520         return VK_SUCCESS;
 521 }
 522
 523 VkResult queueSignalSemaphore (VkQueue queue, VkSemaphore semaphore)
 524 {
 525         DE_UNREF(queue);
 526         DE_UNREF(semaphore);
 527         return VK_SUCCESS;
 528 }
 529
 530 VkResult queueWaitSemaphore (VkQueue queue, VkSemaphore semaphore)
 531 {
 532         DE_UNREF(queue);
 533         DE_UNREF(semaphore);
 534         return VK_SUCCESS;
 535 }
 536
 537 VkResult getEventStatus (VkDevice device, VkEvent event)
 538 {
 539         DE_UNREF(device);
 540         DE_UNREF(event);
 541         return VK_SUCCESS;
 542 }
 543
 544 VkResult setEvent (VkDevice device, VkEvent event)
 545 {
 546         DE_UNREF(device);
 547         DE_UNREF(event);
 548         return VK_SUCCESS;
 549 }
 550
 551 VkResult resetEvent (VkDevice device, VkEvent event)
 552 {
 553         DE_UNREF(device);
 554         DE_UNREF(event);
 555         return VK_SUCCESS;
 556 }
 557
 558 VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr* pDataSize, void* pData, VkQueryResultFlags flags)
 559 {
 560         DE_UNREF(device);
 561         DE_UNREF(queryPool);
 562         DE_UNREF(startQuery);
 563         DE_UNREF(queryCount);
 564         DE_UNREF(pDataSize);
 565         DE_UNREF(pData);
 566         DE_UNREF(flags);
 567         return VK_SUCCESS;
 568 }
 569
 570 VkResult getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
 571 {
 572         DE_UNREF(device);
 573         DE_UNREF(image);
 574         DE_UNREF(pSubresource);
 575         DE_UNREF(pLayout);
 576         return VK_SUCCESS;
 577 }
 578
 579 deUintptr getPipelineCacheSize (VkDevice device, VkPipelineCache pipelineCache)
 580 {
 581         DE_UNREF(device);
 582         DE_UNREF(pipelineCache);
 583         return VK_SUCCESS;
 584 }
 585
 586 VkResult getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, void* pData)
 587 {
 588         DE_UNREF(device);
 589         DE_UNREF(pipelineCache);
 590         DE_UNREF(pData);
 591         return VK_SUCCESS;
 592 }
 593
 594 VkResult mergePipelineCaches (VkDevice device, VkPipelineCache destCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches)
 595 {
 596         DE_UNREF(device);
 597         DE_UNREF(destCache);
 598         DE_UNREF(srcCacheCount);
 599         DE_UNREF(pSrcCaches);
 600         return VK_SUCCESS;
 601 }
 602
 603 VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool)
 604 {
 605         DE_UNREF(device);
 606         DE_UNREF(descriptorPool);
 607         return VK_SUCCESS;
 608 }
 609
 610 VkResult allocDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, deUint32 count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, deUint32* pCount)
 611 {
 612         DE_UNREF(device);
 613         DE_UNREF(descriptorPool);
 614         DE_UNREF(setUsage);
 615         DE_UNREF(count);
 616         DE_UNREF(pSetLayouts);
 617         DE_UNREF(pDescriptorSets);
 618         DE_UNREF(pCount);
 619         return VK_SUCCESS;
 620 }
 621
 622 VkResult freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets)
 623 {
 624         DE_UNREF(device);
 625         DE_UNREF(descriptorPool);
 626         DE_UNREF(count);
 627         DE_UNREF(pDescriptorSets);
 628         return VK_SUCCESS;
 629 }
 630
 631 VkResult updateDescriptorSets (VkDevice device, deUint32 writeCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
 632 {
 633         DE_UNREF(device);
 634         DE_UNREF(writeCount);
 635         DE_UNREF(pDescriptorWrites);
 636         DE_UNREF(copyCount);
 637         DE_UNREF(pDescriptorCopies);
 638         return VK_SUCCESS;
 639 }
 640
 641 VkResult getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
 642 {
 643         DE_UNREF(device);
 644         DE_UNREF(renderPass);
 645         DE_UNREF(pGranularity);
 646         return VK_SUCCESS;
 647 }
 648
 649 VkResult resetCommandPool (VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
 650 {
 651         DE_UNREF(device);
 652         DE_UNREF(cmdPool);
 653         DE_UNREF(flags);
 654         return VK_SUCCESS;
 655 }
 656
 657 VkResult beginCommandBuffer (VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
 658 {
 659         DE_UNREF(cmdBuffer);
 660         DE_UNREF(pBeginInfo);
 661         return VK_SUCCESS;
 662 }
 663
 664 VkResult endCommandBuffer (VkCmdBuffer cmdBuffer)
 665 {
 666         DE_UNREF(cmdBuffer);
 667         return VK_SUCCESS;
 668 }
 669
 670 VkResult resetCommandBuffer (VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags)
 671 {
 672         DE_UNREF(cmdBuffer);
 673         DE_UNREF(flags);
 674         return VK_SUCCESS;
 675 }
 676
 677 void cmdBindPipeline (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 678 {
 679         DE_UNREF(cmdBuffer);
 680         DE_UNREF(pipelineBindPoint);
 681         DE_UNREF(pipeline);
 682 }
 683
 684 void cmdBindDynamicViewportState (VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState)
 685 {
 686         DE_UNREF(cmdBuffer);
 687         DE_UNREF(dynamicViewportState);
 688 }
 689
 690 void cmdBindDynamicRasterState (VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState)
 691 {
 692         DE_UNREF(cmdBuffer);
 693         DE_UNREF(dynamicRasterState);
 694 }
 695
 696 void cmdBindDynamicColorBlendState (VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState)
 697 {
 698         DE_UNREF(cmdBuffer);
 699         DE_UNREF(dynamicColorBlendState);
 700 }
 701
 702 void cmdBindDynamicDepthStencilState (VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState)
 703 {
 704         DE_UNREF(cmdBuffer);
 705         DE_UNREF(dynamicDepthStencilState);
 706 }
 707
 708 void cmdBindDescriptorSets (VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 setCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets)
 709 {
 710         DE_UNREF(cmdBuffer);
 711         DE_UNREF(pipelineBindPoint);
 712         DE_UNREF(layout);
 713         DE_UNREF(firstSet);
 714         DE_UNREF(setCount);
 715         DE_UNREF(pDescriptorSets);
 716         DE_UNREF(dynamicOffsetCount);
 717         DE_UNREF(pDynamicOffsets);
 718 }
 719
 720 void cmdBindIndexBuffer (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 721 {
 722         DE_UNREF(cmdBuffer);
 723         DE_UNREF(buffer);
 724         DE_UNREF(offset);
 725         DE_UNREF(indexType);
 726 }
 727
 728 void cmdBindVertexBuffers (VkCmdBuffer cmdBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
 729 {
 730         DE_UNREF(cmdBuffer);
 731         DE_UNREF(startBinding);
 732         DE_UNREF(bindingCount);
 733         DE_UNREF(pBuffers);
 734         DE_UNREF(pOffsets);
 735 }
 736
 737 void cmdDraw (VkCmdBuffer cmdBuffer, deUint32 firstVertex, deUint32 vertexCount, deUint32 firstInstance, deUint32 instanceCount)
 738 {
 739         DE_UNREF(cmdBuffer);
 740         DE_UNREF(firstVertex);
 741         DE_UNREF(vertexCount);
 742         DE_UNREF(firstInstance);
 743         DE_UNREF(instanceCount);
 744 }
 745
 746 void cmdDrawIndexed (VkCmdBuffer cmdBuffer, deUint32 firstIndex, deUint32 indexCount, deInt32 vertexOffset, deUint32 firstInstance, deUint32 instanceCount)
 747 {
 748         DE_UNREF(cmdBuffer);
 749         DE_UNREF(firstIndex);
 750         DE_UNREF(indexCount);
 751         DE_UNREF(vertexOffset);
 752         DE_UNREF(firstInstance);
 753         DE_UNREF(instanceCount);
 754 }
 755
 756 void cmdDrawIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride)
 757 {
 758         DE_UNREF(cmdBuffer);
 759         DE_UNREF(buffer);
 760         DE_UNREF(offset);
 761         DE_UNREF(count);
 762         DE_UNREF(stride);
 763 }
 764
 765 void cmdDrawIndexedIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 count, deUint32 stride)
 766 {
 767         DE_UNREF(cmdBuffer);
 768         DE_UNREF(buffer);
 769         DE_UNREF(offset);
 770         DE_UNREF(count);
 771         DE_UNREF(stride);
 772 }
 773
 774 void cmdDispatch (VkCmdBuffer cmdBuffer, deUint32 x, deUint32 y, deUint32 z)
 775 {
 776         DE_UNREF(cmdBuffer);
 777         DE_UNREF(x);
 778         DE_UNREF(y);
 779         DE_UNREF(z);
 780 }
 781
 782 void cmdDispatchIndirect (VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
 783 {
 784         DE_UNREF(cmdBuffer);
 785         DE_UNREF(buffer);
 786         DE_UNREF(offset);
 787 }
 788
 789 void cmdCopyBuffer (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, deUint32 regionCount, const VkBufferCopy* pRegions)
 790 {
 791         DE_UNREF(cmdBuffer);
 792         DE_UNREF(srcBuffer);
 793         DE_UNREF(destBuffer);
 794         DE_UNREF(regionCount);
 795         DE_UNREF(pRegions);
 796 }
 797
 798 void cmdCopyImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageCopy* pRegions)
 799 {
 800         DE_UNREF(cmdBuffer);
 801         DE_UNREF(srcImage);
 802         DE_UNREF(srcImageLayout);
 803         DE_UNREF(destImage);
 804         DE_UNREF(destImageLayout);
 805         DE_UNREF(regionCount);
 806         DE_UNREF(pRegions);
 807 }
 808
 809 void cmdBlitImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkTexFilter filter)
 810 {
 811         DE_UNREF(cmdBuffer);
 812         DE_UNREF(srcImage);
 813         DE_UNREF(srcImageLayout);
 814         DE_UNREF(destImage);
 815         DE_UNREF(destImageLayout);
 816         DE_UNREF(regionCount);
 817         DE_UNREF(pRegions);
 818         DE_UNREF(filter);
 819 }
 820
 821 void cmdCopyBufferToImage (VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 822 {
 823         DE_UNREF(cmdBuffer);
 824         DE_UNREF(srcBuffer);
 825         DE_UNREF(destImage);
 826         DE_UNREF(destImageLayout);
 827         DE_UNREF(regionCount);
 828         DE_UNREF(pRegions);
 829 }
 830
 831 void cmdCopyImageToBuffer (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 832 {
 833         DE_UNREF(cmdBuffer);
 834         DE_UNREF(srcImage);
 835         DE_UNREF(srcImageLayout);
 836         DE_UNREF(destBuffer);
 837         DE_UNREF(regionCount);
 838         DE_UNREF(pRegions);
 839 }
 840
 841 void cmdUpdateBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const deUint32* pData)
 842 {
 843         DE_UNREF(cmdBuffer);
 844         DE_UNREF(destBuffer);
 845         DE_UNREF(destOffset);
 846         DE_UNREF(dataSize);
 847         DE_UNREF(pData);
 848 }
 849
 850 void cmdFillBuffer (VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, deUint32 data)
 851 {
 852         DE_UNREF(cmdBuffer);
 853         DE_UNREF(destBuffer);
 854         DE_UNREF(destOffset);
 855         DE_UNREF(fillSize);
 856         DE_UNREF(data);
 857 }
 858
 859 void cmdClearColorImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 860 {
 861         DE_UNREF(cmdBuffer);
 862         DE_UNREF(image);
 863         DE_UNREF(imageLayout);
 864         DE_UNREF(pColor);
 865         DE_UNREF(rangeCount);
 866         DE_UNREF(pRanges);
 867 }
 868
 869 void cmdClearDepthStencilImage (VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 870 {
 871         DE_UNREF(cmdBuffer);
 872         DE_UNREF(image);
 873         DE_UNREF(imageLayout);
 874         DE_UNREF(depth);
 875         DE_UNREF(stencil);
 876         DE_UNREF(rangeCount);
 877         DE_UNREF(pRanges);
 878 }
 879
 880 void cmdClearColorAttachment (VkCmdBuffer cmdBuffer, deUint32 colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rectCount, const VkRect3D* pRects)
 881 {
 882         DE_UNREF(cmdBuffer);
 883         DE_UNREF(colorAttachment);
 884         DE_UNREF(imageLayout);
 885         DE_UNREF(pColor);
 886         DE_UNREF(rectCount);
 887         DE_UNREF(pRects);
 888 }
 889
 890 void cmdClearDepthStencilAttachment (VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, deUint32 stencil, deUint32 rectCount, const VkRect3D* pRects)
 891 {
 892         DE_UNREF(cmdBuffer);
 893         DE_UNREF(imageAspectMask);
 894         DE_UNREF(imageLayout);
 895         DE_UNREF(depth);
 896         DE_UNREF(stencil);
 897         DE_UNREF(rectCount);
 898         DE_UNREF(pRects);
 899 }
 900
 901 void cmdResolveImage (VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, deUint32 regionCount, const VkImageResolve* pRegions)
 902 {
 903         DE_UNREF(cmdBuffer);
 904         DE_UNREF(srcImage);
 905         DE_UNREF(srcImageLayout);
 906         DE_UNREF(destImage);
 907         DE_UNREF(destImageLayout);
 908         DE_UNREF(regionCount);
 909         DE_UNREF(pRegions);
 910 }
 911
 912 void cmdSetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 913 {
 914         DE_UNREF(cmdBuffer);
 915         DE_UNREF(event);
 916         DE_UNREF(stageMask);
 917 }
 918
 919 void cmdResetEvent (VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 920 {
 921         DE_UNREF(cmdBuffer);
 922         DE_UNREF(event);
 923         DE_UNREF(stageMask);
 924 }
 925
 926 void cmdWaitEvents (VkCmdBuffer cmdBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, deUint32 memBarrierCount, const void* const* ppMemBarriers)
 927 {
 928         DE_UNREF(cmdBuffer);
 929         DE_UNREF(eventCount);
 930         DE_UNREF(pEvents);
 931         DE_UNREF(srcStageMask);
 932         DE_UNREF(destStageMask);
 933         DE_UNREF(memBarrierCount);
 934         DE_UNREF(ppMemBarriers);
 935 }
 936
 937 void cmdPipelineBarrier (VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, deUint32 memBarrierCount, const void* const* ppMemBarriers)
 938 {
 939         DE_UNREF(cmdBuffer);
 940         DE_UNREF(srcStageMask);
 941         DE_UNREF(destStageMask);
 942         DE_UNREF(byRegion);
 943         DE_UNREF(memBarrierCount);
 944         DE_UNREF(ppMemBarriers);
 945 }
 946
 947 void cmdBeginQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot, VkQueryControlFlags flags)
 948 {
 949         DE_UNREF(cmdBuffer);
 950         DE_UNREF(queryPool);
 951         DE_UNREF(slot);
 952         DE_UNREF(flags);
 953 }
 954
 955 void cmdEndQuery (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 slot)
 956 {
 957         DE_UNREF(cmdBuffer);
 958         DE_UNREF(queryPool);
 959         DE_UNREF(slot);
 960 }
 961
 962 void cmdResetQueryPool (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount)
 963 {
 964         DE_UNREF(cmdBuffer);
 965         DE_UNREF(queryPool);
 966         DE_UNREF(startQuery);
 967         DE_UNREF(queryCount);
 968 }
 969
 970 void cmdWriteTimestamp (VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset)
 971 {
 972         DE_UNREF(cmdBuffer);
 973         DE_UNREF(timestampType);
 974         DE_UNREF(destBuffer);
 975         DE_UNREF(destOffset);
 976 }
 977
 978 void cmdCopyQueryPoolResults (VkCmdBuffer cmdBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags)
 979 {
 980         DE_UNREF(cmdBuffer);
 981         DE_UNREF(queryPool);
 982         DE_UNREF(startQuery);
 983         DE_UNREF(queryCount);
 984         DE_UNREF(destBuffer);
 985         DE_UNREF(destOffset);
 986         DE_UNREF(destStride);
 987         DE_UNREF(flags);
 988 }
 989
 990 void cmdPushConstants (VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 start, deUint32 length, const void* values)
 991 {
 992         DE_UNREF(cmdBuffer);
 993         DE_UNREF(layout);
 994         DE_UNREF(stageFlags);
 995         DE_UNREF(start);
 996         DE_UNREF(length);
 997         DE_UNREF(values);
 998 }
 999
1000 void cmdBeginRenderPass (VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents)
1001 {
1002         DE_UNREF(cmdBuffer);
1003         DE_UNREF(pRenderPassBegin);
1004         DE_UNREF(contents);
1005 }
1006
1007 void cmdNextSubpass (VkCmdBuffer cmdBuffer, VkRenderPassContents contents)
1008 {
1009         DE_UNREF(cmdBuffer);
1010         DE_UNREF(contents);
1011 }
1012
1013 void cmdEndRenderPass (VkCmdBuffer cmdBuffer)
1014 {
1015         DE_UNREF(cmdBuffer);
1016 }
1017
1018 void cmdExecuteCommands (VkCmdBuffer cmdBuffer, deUint32 cmdBuffersCount, const VkCmdBuffer* pCmdBuffers)
1019 {
1020         DE_UNREF(cmdBuffer);
1021         DE_UNREF(cmdBuffersCount);
1022         DE_UNREF(pCmdBuffers);
1023 }
1024
1025 static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
1026 {
1027         VK_NULL_FUNC_ENTRY(vkCreateInstance,            createInstance),
1028         VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr,       getInstanceProcAddr),
1029 };
1030
1031 static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
1032 {
1033         VK_NULL_FUNC_ENTRY(vkDestroyInstance,                                                   destroyInstance),
1034         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDevices,                                  enumeratePhysicalDevices),
1035         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures,                                 getPhysicalDeviceFeatures),
1036         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties,                 getPhysicalDeviceFormatProperties),
1037         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties,    getPhysicalDeviceImageFormatProperties),
1038         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceLimits,                                   getPhysicalDeviceLimits),
1039         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties,                               getPhysicalDeviceProperties),
1040         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueCount,                               getPhysicalDeviceQueueCount),
1041         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueProperties,                  getPhysicalDeviceQueueProperties),
1042         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties,                 getPhysicalDeviceMemoryProperties),
1043         VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr,                                                 getDeviceProcAddr),
1044         VK_NULL_FUNC_ENTRY(vkCreateDevice,                                                              createDevice),
1045 };
1046
1047 static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
1048 {
1049         VK_NULL_FUNC_ENTRY(vkDestroyDevice,                                                                     destroyDevice),
1050         VK_NULL_FUNC_ENTRY(vkGetGlobalExtensionProperties,                                      getGlobalExtensionProperties),
1051         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExtensionProperties,                      getPhysicalDeviceExtensionProperties),
1052         VK_NULL_FUNC_ENTRY(vkGetGlobalLayerProperties,                                          getGlobalLayerProperties),
1053         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceLayerProperties,                          getPhysicalDeviceLayerProperties),
1054         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue,                                                            getDeviceQueue),
1055         VK_NULL_FUNC_ENTRY(vkQueueSubmit,                                                                       queueSubmit),
1056         VK_NULL_FUNC_ENTRY(vkQueueWaitIdle,                                                                     queueWaitIdle),
1057         VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle,                                                            deviceWaitIdle),
1058         VK_NULL_FUNC_ENTRY(vkAllocMemory,                                                                       allocMemory),
1059         VK_NULL_FUNC_ENTRY(vkFreeMemory,                                                                        freeMemory),
1060         VK_NULL_FUNC_ENTRY(vkMapMemory,                                                                         mapMemory),
1061         VK_NULL_FUNC_ENTRY(vkUnmapMemory,                                                                       unmapMemory),
1062         VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges,                                           flushMappedMemoryRanges),
1063         VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges,                                      invalidateMappedMemoryRanges),
1064         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment,                                         getDeviceMemoryCommitment),
1065         VK_NULL_FUNC_ENTRY(vkBindBufferMemory,                                                          bindBufferMemory),
1066         VK_NULL_FUNC_ENTRY(vkBindImageMemory,                                                           bindImageMemory),
1067         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements,                                       getBufferMemoryRequirements),
1068         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements,                                        getImageMemoryRequirements),
1069         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements,                          getImageSparseMemoryRequirements),
1070         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties,      getPhysicalDeviceSparseImageFormatProperties),
1071         VK_NULL_FUNC_ENTRY(vkQueueBindSparseBufferMemory,                                       queueBindSparseBufferMemory),
1072         VK_NULL_FUNC_ENTRY(vkQueueBindSparseImageOpaqueMemory,                          queueBindSparseImageOpaqueMemory),
1073         VK_NULL_FUNC_ENTRY(vkQueueBindSparseImageMemory,                                        queueBindSparseImageMemory),
1074         VK_NULL_FUNC_ENTRY(vkCreateFence,                                                                       createFence),
1075         VK_NULL_FUNC_ENTRY(vkDestroyFence,                                                                      destroyFence),
1076         VK_NULL_FUNC_ENTRY(vkResetFences,                                                                       resetFences),
1077         VK_NULL_FUNC_ENTRY(vkGetFenceStatus,                                                            getFenceStatus),
1078         VK_NULL_FUNC_ENTRY(vkWaitForFences,                                                                     waitForFences),
1079         VK_NULL_FUNC_ENTRY(vkCreateSemaphore,                                                           createSemaphore),
1080         VK_NULL_FUNC_ENTRY(vkDestroySemaphore,                                                          destroySemaphore),
1081         VK_NULL_FUNC_ENTRY(vkQueueSignalSemaphore,                                                      queueSignalSemaphore),
1082         VK_NULL_FUNC_ENTRY(vkQueueWaitSemaphore,                                                        queueWaitSemaphore),
1083         VK_NULL_FUNC_ENTRY(vkCreateEvent,                                                                       createEvent),
1084         VK_NULL_FUNC_ENTRY(vkDestroyEvent,                                                                      destroyEvent),
1085         VK_NULL_FUNC_ENTRY(vkGetEventStatus,                                                            getEventStatus),
1086         VK_NULL_FUNC_ENTRY(vkSetEvent,                                                                          setEvent),
1087         VK_NULL_FUNC_ENTRY(vkResetEvent,                                                                        resetEvent),
1088         VK_NULL_FUNC_ENTRY(vkCreateQueryPool,                                                           createQueryPool),
1089         VK_NULL_FUNC_ENTRY(vkDestroyQueryPool,                                                          destroyQueryPool),
1090         VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults,                                                       getQueryPoolResults),
1091         VK_NULL_FUNC_ENTRY(vkCreateBuffer,                                                                      createBuffer),
1092         VK_NULL_FUNC_ENTRY(vkDestroyBuffer,                                                                     destroyBuffer),
1093         VK_NULL_FUNC_ENTRY(vkCreateBufferView,                                                          createBufferView),
1094         VK_NULL_FUNC_ENTRY(vkDestroyBufferView,                                                         destroyBufferView),
1095         VK_NULL_FUNC_ENTRY(vkCreateImage,                                                                       createImage),
1096         VK_NULL_FUNC_ENTRY(vkDestroyImage,                                                                      destroyImage),
1097         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout,                                         getImageSubresourceLayout),
1098         VK_NULL_FUNC_ENTRY(vkCreateImageView,                                                           createImageView),
1099         VK_NULL_FUNC_ENTRY(vkDestroyImageView,                                                          destroyImageView),
1100         VK_NULL_FUNC_ENTRY(vkCreateAttachmentView,                                                      createAttachmentView),
1101         VK_NULL_FUNC_ENTRY(vkDestroyAttachmentView,                                                     destroyAttachmentView),
1102         VK_NULL_FUNC_ENTRY(vkCreateShaderModule,                                                        createShaderModule),
1103         VK_NULL_FUNC_ENTRY(vkDestroyShaderModule,                                                       destroyShaderModule),
1104         VK_NULL_FUNC_ENTRY(vkCreateShader,                                                                      createShader),
1105         VK_NULL_FUNC_ENTRY(vkDestroyShader,                                                                     destroyShader),
1106         VK_NULL_FUNC_ENTRY(vkCreatePipelineCache,                                                       createPipelineCache),
1107         VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache,                                                      destroyPipelineCache),
1108         VK_NULL_FUNC_ENTRY(vkGetPipelineCacheSize,                                                      getPipelineCacheSize),
1109         VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData,                                                      getPipelineCacheData),
1110         VK_NULL_FUNC_ENTRY(vkMergePipelineCaches,                                                       mergePipelineCaches),
1111         VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines,                                           createGraphicsPipelines),
1112         VK_NULL_FUNC_ENTRY(vkCreateComputePipelines,                                            createComputePipelines),
1113         VK_NULL_FUNC_ENTRY(vkDestroyPipeline,                                                           destroyPipeline),
1114         VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout,                                                      createPipelineLayout),
1115         VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout,                                                     destroyPipelineLayout),
1116         VK_NULL_FUNC_ENTRY(vkCreateSampler,                                                                     createSampler),
1117         VK_NULL_FUNC_ENTRY(vkDestroySampler,                                                            destroySampler),
1118         VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout,                                         createDescriptorSetLayout),
1119         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout,                                        destroyDescriptorSetLayout),
1120         VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool,                                                      createDescriptorPool),
1121         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool,                                                     destroyDescriptorPool),
1122         VK_NULL_FUNC_ENTRY(vkResetDescriptorPool,                                                       resetDescriptorPool),
1123         VK_NULL_FUNC_ENTRY(vkAllocDescriptorSets,                                                       allocDescriptorSets),
1124         VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets,                                                        freeDescriptorSets),
1125         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets,                                                      updateDescriptorSets),
1126         VK_NULL_FUNC_ENTRY(vkCreateDynamicViewportState,                                        createDynamicViewportState),
1127         VK_NULL_FUNC_ENTRY(vkDestroyDynamicViewportState,                                       destroyDynamicViewportState),
1128         VK_NULL_FUNC_ENTRY(vkCreateDynamicRasterState,                                          createDynamicRasterState),
1129         VK_NULL_FUNC_ENTRY(vkDestroyDynamicRasterState,                                         destroyDynamicRasterState),
1130         VK_NULL_FUNC_ENTRY(vkCreateDynamicColorBlendState,                                      createDynamicColorBlendState),
1131         VK_NULL_FUNC_ENTRY(vkDestroyDynamicColorBlendState,                                     destroyDynamicColorBlendState),
1132         VK_NULL_FUNC_ENTRY(vkCreateDynamicDepthStencilState,                            createDynamicDepthStencilState),
1133         VK_NULL_FUNC_ENTRY(vkDestroyDynamicDepthStencilState,                           destroyDynamicDepthStencilState),
1134         VK_NULL_FUNC_ENTRY(vkCreateFramebuffer,                                                         createFramebuffer),
1135         VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer,                                                        destroyFramebuffer),
1136         VK_NULL_FUNC_ENTRY(vkCreateRenderPass,                                                          createRenderPass),
1137         VK_NULL_FUNC_ENTRY(vkDestroyRenderPass,                                                         destroyRenderPass),
1138         VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity,                                          getRenderAreaGranularity),
1139         VK_NULL_FUNC_ENTRY(vkCreateCommandPool,                                                         createCommandPool),
1140         VK_NULL_FUNC_ENTRY(vkDestroyCommandPool,                                                        destroyCommandPool),
1141         VK_NULL_FUNC_ENTRY(vkResetCommandPool,                                                          resetCommandPool),
1142         VK_NULL_FUNC_ENTRY(vkCreateCommandBuffer,                                                       createCommandBuffer),
1143         VK_NULL_FUNC_ENTRY(vkDestroyCommandBuffer,                                                      destroyCommandBuffer),
1144         VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer,                                                        beginCommandBuffer),
1145         VK_NULL_FUNC_ENTRY(vkEndCommandBuffer,                                                          endCommandBuffer),
1146         VK_NULL_FUNC_ENTRY(vkResetCommandBuffer,                                                        resetCommandBuffer),
1147         VK_NULL_FUNC_ENTRY(vkCmdBindPipeline,                                                           cmdBindPipeline),
1148         VK_NULL_FUNC_ENTRY(vkCmdBindDynamicViewportState,                                       cmdBindDynamicViewportState),
1149         VK_NULL_FUNC_ENTRY(vkCmdBindDynamicRasterState,                                         cmdBindDynamicRasterState),
1150         VK_NULL_FUNC_ENTRY(vkCmdBindDynamicColorBlendState,                                     cmdBindDynamicColorBlendState),
1151         VK_NULL_FUNC_ENTRY(vkCmdBindDynamicDepthStencilState,                           cmdBindDynamicDepthStencilState),
1152         VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets,                                                     cmdBindDescriptorSets),
1153         VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer,                                                        cmdBindIndexBuffer),
1154         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers,                                                      cmdBindVertexBuffers),
1155         VK_NULL_FUNC_ENTRY(vkCmdDraw,                                                                           cmdDraw),
1156         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed,                                                            cmdDrawIndexed),
1157         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect,                                                           cmdDrawIndirect),
1158         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect,                                            cmdDrawIndexedIndirect),
1159         VK_NULL_FUNC_ENTRY(vkCmdDispatch,                                                                       cmdDispatch),
1160         VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect,                                                       cmdDispatchIndirect),
1161         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer,                                                                     cmdCopyBuffer),
1162         VK_NULL_FUNC_ENTRY(vkCmdCopyImage,                                                                      cmdCopyImage),
1163         VK_NULL_FUNC_ENTRY(vkCmdBlitImage,                                                                      cmdBlitImage),
1164         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage,                                                      cmdCopyBufferToImage),
1165         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer,                                                      cmdCopyImageToBuffer),
1166         VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer,                                                           cmdUpdateBuffer),
1167         VK_NULL_FUNC_ENTRY(vkCmdFillBuffer,                                                                     cmdFillBuffer),
1168         VK_NULL_FUNC_ENTRY(vkCmdClearColorImage,                                                        cmdClearColorImage),
1169         VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage,                                         cmdClearDepthStencilImage),
1170         VK_NULL_FUNC_ENTRY(vkCmdClearColorAttachment,                                           cmdClearColorAttachment),
1171         VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilAttachment,                            cmdClearDepthStencilAttachment),
1172         VK_NULL_FUNC_ENTRY(vkCmdResolveImage,                                                           cmdResolveImage),
1173         VK_NULL_FUNC_ENTRY(vkCmdSetEvent,                                                                       cmdSetEvent),
1174         VK_NULL_FUNC_ENTRY(vkCmdResetEvent,                                                                     cmdResetEvent),
1175         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents,                                                                     cmdWaitEvents),
1176         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier,                                                        cmdPipelineBarrier),
1177         VK_NULL_FUNC_ENTRY(vkCmdBeginQuery,                                                                     cmdBeginQuery),
1178         VK_NULL_FUNC_ENTRY(vkCmdEndQuery,                                                                       cmdEndQuery),
1179         VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool,                                                         cmdResetQueryPool),
1180         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp,                                                         cmdWriteTimestamp),
1181         VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults,                                           cmdCopyQueryPoolResults),
1182         VK_NULL_FUNC_ENTRY(vkCmdPushConstants,                                                          cmdPushConstants),
1183         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass,                                                        cmdBeginRenderPass),
1184         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass,                                                            cmdNextSubpass),
1185         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass,                                                          cmdEndRenderPass),
1186         VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands,                                                        cmdExecuteCommands),
1187 };
1188