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 void VKAPI_CALL destroyInstance (VkInstance instance, const VkAllocationCallbacks* pAllocator)
 125 {
 126         freeHandle<Instance, VkInstance>(instance, pAllocator);
 127 }
 128
 129 VKAPI_ATTR void VKAPI_CALL destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator)
 130 {
 131         freeHandle<Device, VkDevice>(device, pAllocator);
 132 }
 133
 134 VKAPI_ATTR void VKAPI_CALL freeMemory (VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
 135 {
 136         DE_UNREF(device);
 137         freeNonDispHandle<DeviceMemory, VkDeviceMemory>(memory, pAllocator);
 138 }
 139
 140 VKAPI_ATTR void VKAPI_CALL destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
 141 {
 142         DE_UNREF(device);
 143         freeNonDispHandle<Fence, VkFence>(fence, pAllocator);
 144 }
 145
 146 VKAPI_ATTR void VKAPI_CALL destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
 147 {
 148         DE_UNREF(device);
 149         freeNonDispHandle<Semaphore, VkSemaphore>(semaphore, pAllocator);
 150 }
 151
 152 VKAPI_ATTR void VKAPI_CALL destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
 153 {
 154         DE_UNREF(device);
 155         freeNonDispHandle<Event, VkEvent>(event, pAllocator);
 156 }
 157
 158 VKAPI_ATTR void VKAPI_CALL destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
 159 {
 160         DE_UNREF(device);
 161         freeNonDispHandle<QueryPool, VkQueryPool>(queryPool, pAllocator);
 162 }
 163
 164 VKAPI_ATTR void VKAPI_CALL destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
 165 {
 166         DE_UNREF(device);
 167         freeNonDispHandle<Buffer, VkBuffer>(buffer, pAllocator);
 168 }
 169
 170 VKAPI_ATTR void VKAPI_CALL destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
 171 {
 172         DE_UNREF(device);
 173         freeNonDispHandle<BufferView, VkBufferView>(bufferView, pAllocator);
 174 }
 175
 176 VKAPI_ATTR void VKAPI_CALL destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 177 {
 178         DE_UNREF(device);
 179         freeNonDispHandle<Image, VkImage>(image, pAllocator);
 180 }
 181
 182 VKAPI_ATTR void VKAPI_CALL destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
 183 {
 184         DE_UNREF(device);
 185         freeNonDispHandle<ImageView, VkImageView>(imageView, pAllocator);
 186 }
 187
 188 VKAPI_ATTR void VKAPI_CALL destroyShaderModule (VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
 189 {
 190         DE_UNREF(device);
 191         freeNonDispHandle<ShaderModule, VkShaderModule>(shaderModule, pAllocator);
 192 }
 193
 194 VKAPI_ATTR void VKAPI_CALL destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
 195 {
 196         DE_UNREF(device);
 197         freeNonDispHandle<PipelineCache, VkPipelineCache>(pipelineCache, pAllocator);
 198 }
 199
 200 VKAPI_ATTR void VKAPI_CALL destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
 201 {
 202         DE_UNREF(device);
 203         freeNonDispHandle<Pipeline, VkPipeline>(pipeline, pAllocator);
 204 }
 205
 206 VKAPI_ATTR void VKAPI_CALL destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
 207 {
 208         DE_UNREF(device);
 209         freeNonDispHandle<PipelineLayout, VkPipelineLayout>(pipelineLayout, pAllocator);
 210 }
 211
 212 VKAPI_ATTR void VKAPI_CALL destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
 213 {
 214         DE_UNREF(device);
 215         freeNonDispHandle<Sampler, VkSampler>(sampler, pAllocator);
 216 }
 217
 218 VKAPI_ATTR void VKAPI_CALL destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
 219 {
 220         DE_UNREF(device);
 221         freeNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(descriptorSetLayout, pAllocator);
 222 }
 223
 224 VKAPI_ATTR void VKAPI_CALL destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
 225 {
 226         DE_UNREF(device);
 227         freeNonDispHandle<DescriptorPool, VkDescriptorPool>(descriptorPool, pAllocator);
 228 }
 229
 230 VKAPI_ATTR void VKAPI_CALL destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
 231 {
 232         DE_UNREF(device);
 233         freeNonDispHandle<Framebuffer, VkFramebuffer>(framebuffer, pAllocator);
 234 }
 235
 236 VKAPI_ATTR void VKAPI_CALL destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
 237 {
 238         DE_UNREF(device);
 239         freeNonDispHandle<RenderPass, VkRenderPass>(renderPass, pAllocator);
 240 }
 241
 242 VKAPI_ATTR void VKAPI_CALL destroyCommandPool (VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
 243 {
 244         DE_UNREF(device);
 245         freeNonDispHandle<CommandPool, VkCommandPool>(commandPool, pAllocator);
 246 }
 247
 248 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
 249 {
 250         DE_UNREF(physicalDevice);
 251         DE_UNREF(pFeatures);
 252 }
 253
 254 VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
 255 {
 256         DE_UNREF(physicalDevice);
 257         DE_UNREF(format);
 258         DE_UNREF(type);
 259         DE_UNREF(tiling);
 260         DE_UNREF(usage);
 261         DE_UNREF(flags);
 262         DE_UNREF(pImageFormatProperties);
 263         return VK_SUCCESS;
 264 }
 265
 266 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceExtensionProperties (const char* pLayerName, deUint32* pPropertyCount, VkExtensionProperties* pProperties)
 267 {
 268         DE_UNREF(pLayerName);
 269         DE_UNREF(pPropertyCount);
 270         DE_UNREF(pProperties);
 271         return VK_SUCCESS;
 272 }
 273
 274 VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, const char* pLayerName, deUint32* pPropertyCount, VkExtensionProperties* pProperties)
 275 {
 276         DE_UNREF(physicalDevice);
 277         DE_UNREF(pLayerName);
 278         DE_UNREF(pPropertyCount);
 279         DE_UNREF(pProperties);
 280         return VK_SUCCESS;
 281 }
 282
 283 VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (deUint32* pPropertyCount, VkLayerProperties* pProperties)
 284 {
 285         DE_UNREF(pPropertyCount);
 286         DE_UNREF(pProperties);
 287         return VK_SUCCESS;
 288 }
 289
 290 VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkLayerProperties* pProperties)
 291 {
 292         DE_UNREF(physicalDevice);
 293         DE_UNREF(pPropertyCount);
 294         DE_UNREF(pProperties);
 295         return VK_SUCCESS;
 296 }
 297
 298 VKAPI_ATTR void VKAPI_CALL getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue)
 299 {
 300         DE_UNREF(device);
 301         DE_UNREF(queueFamilyIndex);
 302         DE_UNREF(queueIndex);
 303         DE_UNREF(pQueue);
 304 }
 305
 306 VKAPI_ATTR VkResult VKAPI_CALL queueSubmit (VkQueue queue, deUint32 submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
 307 {
 308         DE_UNREF(queue);
 309         DE_UNREF(submitCount);
 310         DE_UNREF(pSubmits);
 311         DE_UNREF(fence);
 312         return VK_SUCCESS;
 313 }
 314
 315 VKAPI_ATTR VkResult VKAPI_CALL queueWaitIdle (VkQueue queue)
 316 {
 317         DE_UNREF(queue);
 318         return VK_SUCCESS;
 319 }
 320
 321 VKAPI_ATTR VkResult VKAPI_CALL deviceWaitIdle (VkDevice device)
 322 {
 323         DE_UNREF(device);
 324         return VK_SUCCESS;
 325 }
 326
 327 VKAPI_ATTR void VKAPI_CALL unmapMemory (VkDevice device, VkDeviceMemory memory)
 328 {
 329         DE_UNREF(device);
 330         DE_UNREF(memory);
 331 }
 332
 333 VKAPI_ATTR VkResult VKAPI_CALL flushMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 334 {
 335         DE_UNREF(device);
 336         DE_UNREF(memoryRangeCount);
 337         DE_UNREF(pMemoryRanges);
 338         return VK_SUCCESS;
 339 }
 340
 341 VKAPI_ATTR VkResult VKAPI_CALL invalidateMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 342 {
 343         DE_UNREF(device);
 344         DE_UNREF(memoryRangeCount);
 345         DE_UNREF(pMemoryRanges);
 346         return VK_SUCCESS;
 347 }
 348
 349 VKAPI_ATTR void VKAPI_CALL getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
 350 {
 351         DE_UNREF(device);
 352         DE_UNREF(memory);
 353         DE_UNREF(pCommittedMemoryInBytes);
 354 }
 355
 356 VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 357 {
 358         DE_UNREF(device);
 359         DE_UNREF(buffer);
 360         DE_UNREF(memory);
 361         DE_UNREF(memoryOffset);
 362         return VK_SUCCESS;
 363 }
 364
 365 VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 366 {
 367         DE_UNREF(device);
 368         DE_UNREF(image);
 369         DE_UNREF(memory);
 370         DE_UNREF(memoryOffset);
 371         return VK_SUCCESS;
 372 }
 373
 374 VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements (VkDevice device, VkImage image, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 375 {
 376         DE_UNREF(device);
 377         DE_UNREF(image);
 378         DE_UNREF(pSparseMemoryRequirementCount);
 379         DE_UNREF(pSparseMemoryRequirements);
 380 }
 381
 382 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, deUint32* pPropertyCount, VkSparseImageFormatProperties* pProperties)
 383 {
 384         DE_UNREF(physicalDevice);
 385         DE_UNREF(format);
 386         DE_UNREF(type);
 387         DE_UNREF(samples);
 388         DE_UNREF(usage);
 389         DE_UNREF(tiling);
 390         DE_UNREF(pPropertyCount);
 391         DE_UNREF(pProperties);
 392 }
 393
 394 VKAPI_ATTR VkResult VKAPI_CALL queueBindSparse (VkQueue queue, deUint32 bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
 395 {
 396         DE_UNREF(queue);
 397         DE_UNREF(bindInfoCount);
 398         DE_UNREF(pBindInfo);
 399         DE_UNREF(fence);
 400         return VK_SUCCESS;
 401 }
 402
 403 VKAPI_ATTR VkResult VKAPI_CALL resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences)
 404 {
 405         DE_UNREF(device);
 406         DE_UNREF(fenceCount);
 407         DE_UNREF(pFences);
 408         return VK_SUCCESS;
 409 }
 410
 411 VKAPI_ATTR VkResult VKAPI_CALL getFenceStatus (VkDevice device, VkFence fence)
 412 {
 413         DE_UNREF(device);
 414         DE_UNREF(fence);
 415         return VK_SUCCESS;
 416 }
 417
 418 VKAPI_ATTR VkResult VKAPI_CALL waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout)
 419 {
 420         DE_UNREF(device);
 421         DE_UNREF(fenceCount);
 422         DE_UNREF(pFences);
 423         DE_UNREF(waitAll);
 424         DE_UNREF(timeout);
 425         return VK_SUCCESS;
 426 }
 427
 428 VKAPI_ATTR VkResult VKAPI_CALL getEventStatus (VkDevice device, VkEvent event)
 429 {
 430         DE_UNREF(device);
 431         DE_UNREF(event);
 432         return VK_SUCCESS;
 433 }
 434
 435 VKAPI_ATTR VkResult VKAPI_CALL setEvent (VkDevice device, VkEvent event)
 436 {
 437         DE_UNREF(device);
 438         DE_UNREF(event);
 439         return VK_SUCCESS;
 440 }
 441
 442 VKAPI_ATTR VkResult VKAPI_CALL resetEvent (VkDevice device, VkEvent event)
 443 {
 444         DE_UNREF(device);
 445         DE_UNREF(event);
 446         return VK_SUCCESS;
 447 }
 448
 449 VKAPI_ATTR VkResult VKAPI_CALL getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
 450 {
 451         DE_UNREF(device);
 452         DE_UNREF(queryPool);
 453         DE_UNREF(firstQuery);
 454         DE_UNREF(queryCount);
 455         DE_UNREF(dataSize);
 456         DE_UNREF(pData);
 457         DE_UNREF(stride);
 458         DE_UNREF(flags);
 459         return VK_SUCCESS;
 460 }
 461
 462 VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
 463 {
 464         DE_UNREF(device);
 465         DE_UNREF(image);
 466         DE_UNREF(pSubresource);
 467         DE_UNREF(pLayout);
 468 }
 469
 470 VKAPI_ATTR VkResult VKAPI_CALL getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, deUintptr* pDataSize, void* pData)
 471 {
 472         DE_UNREF(device);
 473         DE_UNREF(pipelineCache);
 474         DE_UNREF(pDataSize);
 475         DE_UNREF(pData);
 476         return VK_SUCCESS;
 477 }
 478
 479 VKAPI_ATTR VkResult VKAPI_CALL mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches)
 480 {
 481         DE_UNREF(device);
 482         DE_UNREF(dstCache);
 483         DE_UNREF(srcCacheCount);
 484         DE_UNREF(pSrcCaches);
 485         return VK_SUCCESS;
 486 }
 487
 488 VKAPI_ATTR void VKAPI_CALL updateDescriptorSets (VkDevice device, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
 489 {
 490         DE_UNREF(device);
 491         DE_UNREF(descriptorWriteCount);
 492         DE_UNREF(pDescriptorWrites);
 493         DE_UNREF(descriptorCopyCount);
 494         DE_UNREF(pDescriptorCopies);
 495 }
 496
 497 VKAPI_ATTR void VKAPI_CALL getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
 498 {
 499         DE_UNREF(device);
 500         DE_UNREF(renderPass);
 501         DE_UNREF(pGranularity);
 502 }
 503
 504 VKAPI_ATTR VkResult VKAPI_CALL resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 505 {
 506         DE_UNREF(device);
 507         DE_UNREF(commandPool);
 508         DE_UNREF(flags);
 509         return VK_SUCCESS;
 510 }
 511
 512 VKAPI_ATTR VkResult VKAPI_CALL beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
 513 {
 514         DE_UNREF(commandBuffer);
 515         DE_UNREF(pBeginInfo);
 516         return VK_SUCCESS;
 517 }
 518
 519 VKAPI_ATTR VkResult VKAPI_CALL endCommandBuffer (VkCommandBuffer commandBuffer)
 520 {
 521         DE_UNREF(commandBuffer);
 522         return VK_SUCCESS;
 523 }
 524
 525 VKAPI_ATTR VkResult VKAPI_CALL resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 526 {
 527         DE_UNREF(commandBuffer);
 528         DE_UNREF(flags);
 529         return VK_SUCCESS;
 530 }
 531
 532 VKAPI_ATTR void VKAPI_CALL cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 533 {
 534         DE_UNREF(commandBuffer);
 535         DE_UNREF(pipelineBindPoint);
 536         DE_UNREF(pipeline);
 537 }
 538
 539 VKAPI_ATTR void VKAPI_CALL cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports)
 540 {
 541         DE_UNREF(commandBuffer);
 542         DE_UNREF(firstViewport);
 543         DE_UNREF(viewportCount);
 544         DE_UNREF(pViewports);
 545 }
 546
 547 VKAPI_ATTR void VKAPI_CALL cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors)
 548 {
 549         DE_UNREF(commandBuffer);
 550         DE_UNREF(firstScissor);
 551         DE_UNREF(scissorCount);
 552         DE_UNREF(pScissors);
 553 }
 554
 555 VKAPI_ATTR void VKAPI_CALL cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth)
 556 {
 557         DE_UNREF(commandBuffer);
 558         DE_UNREF(lineWidth);
 559 }
 560
 561 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 562 {
 563         DE_UNREF(commandBuffer);
 564         DE_UNREF(depthBiasConstantFactor);
 565         DE_UNREF(depthBiasClamp);
 566         DE_UNREF(depthBiasSlopeFactor);
 567 }
 568
 569 VKAPI_ATTR void VKAPI_CALL cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4])
 570 {
 571         DE_UNREF(commandBuffer);
 572         DE_UNREF(blendConstants);
 573 }
 574
 575 VKAPI_ATTR void VKAPI_CALL cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 576 {
 577         DE_UNREF(commandBuffer);
 578         DE_UNREF(minDepthBounds);
 579         DE_UNREF(maxDepthBounds);
 580 }
 581
 582 VKAPI_ATTR void VKAPI_CALL cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 compareMask)
 583 {
 584         DE_UNREF(commandBuffer);
 585         DE_UNREF(faceMask);
 586         DE_UNREF(compareMask);
 587 }
 588
 589 VKAPI_ATTR void VKAPI_CALL cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 writeMask)
 590 {
 591         DE_UNREF(commandBuffer);
 592         DE_UNREF(faceMask);
 593         DE_UNREF(writeMask);
 594 }
 595
 596 VKAPI_ATTR void VKAPI_CALL cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 reference)
 597 {
 598         DE_UNREF(commandBuffer);
 599         DE_UNREF(faceMask);
 600         DE_UNREF(reference);
 601 }
 602
 603 VKAPI_ATTR void VKAPI_CALL cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 descriptorSetCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets)
 604 {
 605         DE_UNREF(commandBuffer);
 606         DE_UNREF(pipelineBindPoint);
 607         DE_UNREF(layout);
 608         DE_UNREF(firstSet);
 609         DE_UNREF(descriptorSetCount);
 610         DE_UNREF(pDescriptorSets);
 611         DE_UNREF(dynamicOffsetCount);
 612         DE_UNREF(pDynamicOffsets);
 613 }
 614
 615 VKAPI_ATTR void VKAPI_CALL cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 616 {
 617         DE_UNREF(commandBuffer);
 618         DE_UNREF(buffer);
 619         DE_UNREF(offset);
 620         DE_UNREF(indexType);
 621 }
 622
 623 VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
 624 {
 625         DE_UNREF(commandBuffer);
 626         DE_UNREF(firstBinding);
 627         DE_UNREF(bindingCount);
 628         DE_UNREF(pBuffers);
 629         DE_UNREF(pOffsets);
 630 }
 631
 632 VKAPI_ATTR void VKAPI_CALL cmdDraw (VkCommandBuffer commandBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance)
 633 {
 634         DE_UNREF(commandBuffer);
 635         DE_UNREF(vertexCount);
 636         DE_UNREF(instanceCount);
 637         DE_UNREF(firstVertex);
 638         DE_UNREF(firstInstance);
 639 }
 640
 641 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexed (VkCommandBuffer commandBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance)
 642 {
 643         DE_UNREF(commandBuffer);
 644         DE_UNREF(indexCount);
 645         DE_UNREF(instanceCount);
 646         DE_UNREF(firstIndex);
 647         DE_UNREF(vertexOffset);
 648         DE_UNREF(firstInstance);
 649 }
 650
 651 VKAPI_ATTR void VKAPI_CALL cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride)
 652 {
 653         DE_UNREF(commandBuffer);
 654         DE_UNREF(buffer);
 655         DE_UNREF(offset);
 656         DE_UNREF(drawCount);
 657         DE_UNREF(stride);
 658 }
 659
 660 VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride)
 661 {
 662         DE_UNREF(commandBuffer);
 663         DE_UNREF(buffer);
 664         DE_UNREF(offset);
 665         DE_UNREF(drawCount);
 666         DE_UNREF(stride);
 667 }
 668
 669 VKAPI_ATTR void VKAPI_CALL cmdDispatch (VkCommandBuffer commandBuffer, deUint32 x, deUint32 y, deUint32 z)
 670 {
 671         DE_UNREF(commandBuffer);
 672         DE_UNREF(x);
 673         DE_UNREF(y);
 674         DE_UNREF(z);
 675 }
 676
 677 VKAPI_ATTR void VKAPI_CALL cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 678 {
 679         DE_UNREF(commandBuffer);
 680         DE_UNREF(buffer);
 681         DE_UNREF(offset);
 682 }
 683
 684 VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferCopy* pRegions)
 685 {
 686         DE_UNREF(commandBuffer);
 687         DE_UNREF(srcBuffer);
 688         DE_UNREF(dstBuffer);
 689         DE_UNREF(regionCount);
 690         DE_UNREF(pRegions);
 691 }
 692
 693 VKAPI_ATTR void VKAPI_CALL cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageCopy* pRegions)
 694 {
 695         DE_UNREF(commandBuffer);
 696         DE_UNREF(srcImage);
 697         DE_UNREF(srcImageLayout);
 698         DE_UNREF(dstImage);
 699         DE_UNREF(dstImageLayout);
 700         DE_UNREF(regionCount);
 701         DE_UNREF(pRegions);
 702 }
 703
 704 VKAPI_ATTR void VKAPI_CALL cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkFilter filter)
 705 {
 706         DE_UNREF(commandBuffer);
 707         DE_UNREF(srcImage);
 708         DE_UNREF(srcImageLayout);
 709         DE_UNREF(dstImage);
 710         DE_UNREF(dstImageLayout);
 711         DE_UNREF(regionCount);
 712         DE_UNREF(pRegions);
 713         DE_UNREF(filter);
 714 }
 715
 716 VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 717 {
 718         DE_UNREF(commandBuffer);
 719         DE_UNREF(srcBuffer);
 720         DE_UNREF(dstImage);
 721         DE_UNREF(dstImageLayout);
 722         DE_UNREF(regionCount);
 723         DE_UNREF(pRegions);
 724 }
 725
 726 VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions)
 727 {
 728         DE_UNREF(commandBuffer);
 729         DE_UNREF(srcImage);
 730         DE_UNREF(srcImageLayout);
 731         DE_UNREF(dstBuffer);
 732         DE_UNREF(regionCount);
 733         DE_UNREF(pRegions);
 734 }
 735
 736 VKAPI_ATTR void VKAPI_CALL cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const deUint32* pData)
 737 {
 738         DE_UNREF(commandBuffer);
 739         DE_UNREF(dstBuffer);
 740         DE_UNREF(dstOffset);
 741         DE_UNREF(dataSize);
 742         DE_UNREF(pData);
 743 }
 744
 745 VKAPI_ATTR void VKAPI_CALL cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, deUint32 data)
 746 {
 747         DE_UNREF(commandBuffer);
 748         DE_UNREF(dstBuffer);
 749         DE_UNREF(dstOffset);
 750         DE_UNREF(size);
 751         DE_UNREF(data);
 752 }
 753
 754 VKAPI_ATTR void VKAPI_CALL cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 755 {
 756         DE_UNREF(commandBuffer);
 757         DE_UNREF(image);
 758         DE_UNREF(imageLayout);
 759         DE_UNREF(pColor);
 760         DE_UNREF(rangeCount);
 761         DE_UNREF(pRanges);
 762 }
 763
 764 VKAPI_ATTR void VKAPI_CALL cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges)
 765 {
 766         DE_UNREF(commandBuffer);
 767         DE_UNREF(image);
 768         DE_UNREF(imageLayout);
 769         DE_UNREF(pDepthStencil);
 770         DE_UNREF(rangeCount);
 771         DE_UNREF(pRanges);
 772 }
 773
 774 VKAPI_ATTR void VKAPI_CALL cmdClearAttachments (VkCommandBuffer commandBuffer, deUint32 attachmentCount, const VkClearAttachment* pAttachments, deUint32 rectCount, const VkClearRect* pRects)
 775 {
 776         DE_UNREF(commandBuffer);
 777         DE_UNREF(attachmentCount);
 778         DE_UNREF(pAttachments);
 779         DE_UNREF(rectCount);
 780         DE_UNREF(pRects);
 781 }
 782
 783 VKAPI_ATTR void VKAPI_CALL cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageResolve* pRegions)
 784 {
 785         DE_UNREF(commandBuffer);
 786         DE_UNREF(srcImage);
 787         DE_UNREF(srcImageLayout);
 788         DE_UNREF(dstImage);
 789         DE_UNREF(dstImageLayout);
 790         DE_UNREF(regionCount);
 791         DE_UNREF(pRegions);
 792 }
 793
 794 VKAPI_ATTR void VKAPI_CALL cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 795 {
 796         DE_UNREF(commandBuffer);
 797         DE_UNREF(event);
 798         DE_UNREF(stageMask);
 799 }
 800
 801 VKAPI_ATTR void VKAPI_CALL cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 802 {
 803         DE_UNREF(commandBuffer);
 804         DE_UNREF(event);
 805         DE_UNREF(stageMask);
 806 }
 807
 808 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)
 809 {
 810         DE_UNREF(commandBuffer);
 811         DE_UNREF(eventCount);
 812         DE_UNREF(pEvents);
 813         DE_UNREF(srcStageMask);
 814         DE_UNREF(dstStageMask);
 815         DE_UNREF(memoryBarrierCount);
 816         DE_UNREF(pMemoryBarriers);
 817         DE_UNREF(bufferMemoryBarrierCount);
 818         DE_UNREF(pBufferMemoryBarriers);
 819         DE_UNREF(imageMemoryBarrierCount);
 820         DE_UNREF(pImageMemoryBarriers);
 821 }
 822
 823 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)
 824 {
 825         DE_UNREF(commandBuffer);
 826         DE_UNREF(srcStageMask);
 827         DE_UNREF(dstStageMask);
 828         DE_UNREF(dependencyFlags);
 829         DE_UNREF(memoryBarrierCount);
 830         DE_UNREF(pMemoryBarriers);
 831         DE_UNREF(bufferMemoryBarrierCount);
 832         DE_UNREF(pBufferMemoryBarriers);
 833         DE_UNREF(imageMemoryBarrierCount);
 834         DE_UNREF(pImageMemoryBarriers);
 835 }
 836
 837 VKAPI_ATTR void VKAPI_CALL cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags)
 838 {
 839         DE_UNREF(commandBuffer);
 840         DE_UNREF(queryPool);
 841         DE_UNREF(query);
 842         DE_UNREF(flags);
 843 }
 844
 845 VKAPI_ATTR void VKAPI_CALL cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query)
 846 {
 847         DE_UNREF(commandBuffer);
 848         DE_UNREF(queryPool);
 849         DE_UNREF(query);
 850 }
 851
 852 VKAPI_ATTR void VKAPI_CALL cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount)
 853 {
 854         DE_UNREF(commandBuffer);
 855         DE_UNREF(queryPool);
 856         DE_UNREF(firstQuery);
 857         DE_UNREF(queryCount);
 858 }
 859
 860 VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query)
 861 {
 862         DE_UNREF(commandBuffer);
 863         DE_UNREF(pipelineStage);
 864         DE_UNREF(queryPool);
 865         DE_UNREF(query);
 866 }
 867
 868 VKAPI_ATTR void VKAPI_CALL cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 869 {
 870         DE_UNREF(commandBuffer);
 871         DE_UNREF(queryPool);
 872         DE_UNREF(firstQuery);
 873         DE_UNREF(queryCount);
 874         DE_UNREF(dstBuffer);
 875         DE_UNREF(dstOffset);
 876         DE_UNREF(stride);
 877         DE_UNREF(flags);
 878 }
 879
 880 VKAPI_ATTR void VKAPI_CALL cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 offset, deUint32 size, const void* pValues)
 881 {
 882         DE_UNREF(commandBuffer);
 883         DE_UNREF(layout);
 884         DE_UNREF(stageFlags);
 885         DE_UNREF(offset);
 886         DE_UNREF(size);
 887         DE_UNREF(pValues);
 888 }
 889
 890 VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
 891 {
 892         DE_UNREF(commandBuffer);
 893         DE_UNREF(pRenderPassBegin);
 894         DE_UNREF(contents);
 895 }
 896
 897 VKAPI_ATTR void VKAPI_CALL cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents)
 898 {
 899         DE_UNREF(commandBuffer);
 900         DE_UNREF(contents);
 901 }
 902
 903 VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass (VkCommandBuffer commandBuffer)
 904 {
 905         DE_UNREF(commandBuffer);
 906 }
 907
 908 VKAPI_ATTR void VKAPI_CALL cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers)
 909 {
 910         DE_UNREF(commandBuffer);
 911         DE_UNREF(commandBufferCount);
 912         DE_UNREF(pCommandBuffers);
 913 }
 914
 915 static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
 916 {
 917         VK_NULL_FUNC_ENTRY(vkCreateInstance,                                            createInstance),
 918         VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr,                                       getInstanceProcAddr),
 919         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceExtensionProperties,      enumerateInstanceExtensionProperties),
 920         VK_NULL_FUNC_ENTRY(vkEnumerateInstanceLayerProperties,          enumerateInstanceLayerProperties),
 921 };
 922
 923 static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
 924 {
 925         VK_NULL_FUNC_ENTRY(vkDestroyInstance,                                                   destroyInstance),
 926         VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDevices,                                  enumeratePhysicalDevices),
 927         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures,                                 getPhysicalDeviceFeatures),
 928         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties,                 getPhysicalDeviceFormatProperties),
 929         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties,    getPhysicalDeviceImageFormatProperties),
 930         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties,                               getPhysicalDeviceProperties),
 931         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties,    getPhysicalDeviceQueueFamilyProperties),
 932         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties,                 getPhysicalDeviceMemoryProperties),
 933         VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr,                                                 getDeviceProcAddr),
 934         VK_NULL_FUNC_ENTRY(vkCreateDevice,                                                              createDevice),
 935         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceExtensionProperties,                enumerateDeviceExtensionProperties),
 936         VK_NULL_FUNC_ENTRY(vkEnumerateDeviceLayerProperties,                    enumerateDeviceLayerProperties),
 937 };
 938
 939 static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
 940 {
 941         VK_NULL_FUNC_ENTRY(vkDestroyDevice,                                                                     destroyDevice),
 942         VK_NULL_FUNC_ENTRY(vkGetDeviceQueue,                                                            getDeviceQueue),
 943         VK_NULL_FUNC_ENTRY(vkQueueSubmit,                                                                       queueSubmit),
 944         VK_NULL_FUNC_ENTRY(vkQueueWaitIdle,                                                                     queueWaitIdle),
 945         VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle,                                                            deviceWaitIdle),
 946         VK_NULL_FUNC_ENTRY(vkAllocateMemory,                                                            allocateMemory),
 947         VK_NULL_FUNC_ENTRY(vkFreeMemory,                                                                        freeMemory),
 948         VK_NULL_FUNC_ENTRY(vkMapMemory,                                                                         mapMemory),
 949         VK_NULL_FUNC_ENTRY(vkUnmapMemory,                                                                       unmapMemory),
 950         VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges,                                           flushMappedMemoryRanges),
 951         VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges,                                      invalidateMappedMemoryRanges),
 952         VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment,                                         getDeviceMemoryCommitment),
 953         VK_NULL_FUNC_ENTRY(vkBindBufferMemory,                                                          bindBufferMemory),
 954         VK_NULL_FUNC_ENTRY(vkBindImageMemory,                                                           bindImageMemory),
 955         VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements,                                       getBufferMemoryRequirements),
 956         VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements,                                        getImageMemoryRequirements),
 957         VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements,                          getImageSparseMemoryRequirements),
 958         VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties,      getPhysicalDeviceSparseImageFormatProperties),
 959         VK_NULL_FUNC_ENTRY(vkQueueBindSparse,                                                           queueBindSparse),
 960         VK_NULL_FUNC_ENTRY(vkCreateFence,                                                                       createFence),
 961         VK_NULL_FUNC_ENTRY(vkDestroyFence,                                                                      destroyFence),
 962         VK_NULL_FUNC_ENTRY(vkResetFences,                                                                       resetFences),
 963         VK_NULL_FUNC_ENTRY(vkGetFenceStatus,                                                            getFenceStatus),
 964         VK_NULL_FUNC_ENTRY(vkWaitForFences,                                                                     waitForFences),
 965         VK_NULL_FUNC_ENTRY(vkCreateSemaphore,                                                           createSemaphore),
 966         VK_NULL_FUNC_ENTRY(vkDestroySemaphore,                                                          destroySemaphore),
 967         VK_NULL_FUNC_ENTRY(vkCreateEvent,                                                                       createEvent),
 968         VK_NULL_FUNC_ENTRY(vkDestroyEvent,                                                                      destroyEvent),
 969         VK_NULL_FUNC_ENTRY(vkGetEventStatus,                                                            getEventStatus),
 970         VK_NULL_FUNC_ENTRY(vkSetEvent,                                                                          setEvent),
 971         VK_NULL_FUNC_ENTRY(vkResetEvent,                                                                        resetEvent),
 972         VK_NULL_FUNC_ENTRY(vkCreateQueryPool,                                                           createQueryPool),
 973         VK_NULL_FUNC_ENTRY(vkDestroyQueryPool,                                                          destroyQueryPool),
 974         VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults,                                                       getQueryPoolResults),
 975         VK_NULL_FUNC_ENTRY(vkCreateBuffer,                                                                      createBuffer),
 976         VK_NULL_FUNC_ENTRY(vkDestroyBuffer,                                                                     destroyBuffer),
 977         VK_NULL_FUNC_ENTRY(vkCreateBufferView,                                                          createBufferView),
 978         VK_NULL_FUNC_ENTRY(vkDestroyBufferView,                                                         destroyBufferView),
 979         VK_NULL_FUNC_ENTRY(vkCreateImage,                                                                       createImage),
 980         VK_NULL_FUNC_ENTRY(vkDestroyImage,                                                                      destroyImage),
 981         VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout,                                         getImageSubresourceLayout),
 982         VK_NULL_FUNC_ENTRY(vkCreateImageView,                                                           createImageView),
 983         VK_NULL_FUNC_ENTRY(vkDestroyImageView,                                                          destroyImageView),
 984         VK_NULL_FUNC_ENTRY(vkCreateShaderModule,                                                        createShaderModule),
 985         VK_NULL_FUNC_ENTRY(vkDestroyShaderModule,                                                       destroyShaderModule),
 986         VK_NULL_FUNC_ENTRY(vkCreatePipelineCache,                                                       createPipelineCache),
 987         VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache,                                                      destroyPipelineCache),
 988         VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData,                                                      getPipelineCacheData),
 989         VK_NULL_FUNC_ENTRY(vkMergePipelineCaches,                                                       mergePipelineCaches),
 990         VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines,                                           createGraphicsPipelines),
 991         VK_NULL_FUNC_ENTRY(vkCreateComputePipelines,                                            createComputePipelines),
 992         VK_NULL_FUNC_ENTRY(vkDestroyPipeline,                                                           destroyPipeline),
 993         VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout,                                                      createPipelineLayout),
 994         VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout,                                                     destroyPipelineLayout),
 995         VK_NULL_FUNC_ENTRY(vkCreateSampler,                                                                     createSampler),
 996         VK_NULL_FUNC_ENTRY(vkDestroySampler,                                                            destroySampler),
 997         VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout,                                         createDescriptorSetLayout),
 998         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout,                                        destroyDescriptorSetLayout),
 999         VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool,                                                      createDescriptorPool),
1000         VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool,                                                     destroyDescriptorPool),
1001         VK_NULL_FUNC_ENTRY(vkResetDescriptorPool,                                                       resetDescriptorPool),
1002         VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets,                                            allocateDescriptorSets),
1003         VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets,                                                        freeDescriptorSets),
1004         VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets,                                                      updateDescriptorSets),
1005         VK_NULL_FUNC_ENTRY(vkCreateFramebuffer,                                                         createFramebuffer),
1006         VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer,                                                        destroyFramebuffer),
1007         VK_NULL_FUNC_ENTRY(vkCreateRenderPass,                                                          createRenderPass),
1008         VK_NULL_FUNC_ENTRY(vkDestroyRenderPass,                                                         destroyRenderPass),
1009         VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity,                                          getRenderAreaGranularity),
1010         VK_NULL_FUNC_ENTRY(vkCreateCommandPool,                                                         createCommandPool),
1011         VK_NULL_FUNC_ENTRY(vkDestroyCommandPool,                                                        destroyCommandPool),
1012         VK_NULL_FUNC_ENTRY(vkResetCommandPool,                                                          resetCommandPool),
1013         VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers,                                            allocateCommandBuffers),
1014         VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers,                                                        freeCommandBuffers),
1015         VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer,                                                        beginCommandBuffer),
1016         VK_NULL_FUNC_ENTRY(vkEndCommandBuffer,                                                          endCommandBuffer),
1017         VK_NULL_FUNC_ENTRY(vkResetCommandBuffer,                                                        resetCommandBuffer),
1018         VK_NULL_FUNC_ENTRY(vkCmdBindPipeline,                                                           cmdBindPipeline),
1019         VK_NULL_FUNC_ENTRY(vkCmdSetViewport,                                                            cmdSetViewport),
1020         VK_NULL_FUNC_ENTRY(vkCmdSetScissor,                                                                     cmdSetScissor),
1021         VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth,                                                           cmdSetLineWidth),
1022         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias,                                                           cmdSetDepthBias),
1023         VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants,                                                      cmdSetBlendConstants),
1024         VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds,                                                         cmdSetDepthBounds),
1025         VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask,                                          cmdSetStencilCompareMask),
1026         VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask,                                            cmdSetStencilWriteMask),
1027         VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference,                                            cmdSetStencilReference),
1028         VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets,                                                     cmdBindDescriptorSets),
1029         VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer,                                                        cmdBindIndexBuffer),
1030         VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers,                                                      cmdBindVertexBuffers),
1031         VK_NULL_FUNC_ENTRY(vkCmdDraw,                                                                           cmdDraw),
1032         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed,                                                            cmdDrawIndexed),
1033         VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect,                                                           cmdDrawIndirect),
1034         VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect,                                            cmdDrawIndexedIndirect),
1035         VK_NULL_FUNC_ENTRY(vkCmdDispatch,                                                                       cmdDispatch),
1036         VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect,                                                       cmdDispatchIndirect),
1037         VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer,                                                                     cmdCopyBuffer),
1038         VK_NULL_FUNC_ENTRY(vkCmdCopyImage,                                                                      cmdCopyImage),
1039         VK_NULL_FUNC_ENTRY(vkCmdBlitImage,                                                                      cmdBlitImage),
1040         VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage,                                                      cmdCopyBufferToImage),
1041         VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer,                                                      cmdCopyImageToBuffer),
1042         VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer,                                                           cmdUpdateBuffer),
1043         VK_NULL_FUNC_ENTRY(vkCmdFillBuffer,                                                                     cmdFillBuffer),
1044         VK_NULL_FUNC_ENTRY(vkCmdClearColorImage,                                                        cmdClearColorImage),
1045         VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage,                                         cmdClearDepthStencilImage),
1046         VK_NULL_FUNC_ENTRY(vkCmdClearAttachments,                                                       cmdClearAttachments),
1047         VK_NULL_FUNC_ENTRY(vkCmdResolveImage,                                                           cmdResolveImage),
1048         VK_NULL_FUNC_ENTRY(vkCmdSetEvent,                                                                       cmdSetEvent),
1049         VK_NULL_FUNC_ENTRY(vkCmdResetEvent,                                                                     cmdResetEvent),
1050         VK_NULL_FUNC_ENTRY(vkCmdWaitEvents,                                                                     cmdWaitEvents),
1051         VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier,                                                        cmdPipelineBarrier),
1052         VK_NULL_FUNC_ENTRY(vkCmdBeginQuery,                                                                     cmdBeginQuery),
1053         VK_NULL_FUNC_ENTRY(vkCmdEndQuery,                                                                       cmdEndQuery),
1054         VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool,                                                         cmdResetQueryPool),
1055         VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp,                                                         cmdWriteTimestamp),
1056         VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults,                                           cmdCopyQueryPoolResults),
1057         VK_NULL_FUNC_ENTRY(vkCmdPushConstants,                                                          cmdPushConstants),
1058         VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass,                                                        cmdBeginRenderPass),
1059         VK_NULL_FUNC_ENTRY(vkCmdNextSubpass,                                                            cmdNextSubpass),
1060         VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass,                                                          cmdEndRenderPass),
1061         VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands,                                                        cmdExecuteCommands),
1062 };
1063