external/vulkancts/framework/vulkan/vkDeviceDriverImpl.inl

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  */
   4
   5 PFN_vkVoidFunction DeviceDriver::getDeviceProcAddr (VkDevice device, const char* pName) const
   6 {
   7         return m_vk.getDeviceProcAddr(device, pName);
   8 }
   9
  10 void DeviceDriver::destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator) const
  11 {
  12         m_vk.destroyDevice(device, pAllocator);
  13 }
  14
  15 void DeviceDriver::getDeviceQueue (VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex, VkQueue* pQueue) const
  16 {
  17         m_vk.getDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
  18 }
  19
  20 VkResult DeviceDriver::queueSubmit (VkQueue queue, deUint32 submitCount, const VkSubmitInfo* pSubmits, VkFence fence) const
  21 {
  22         return m_vk.queueSubmit(queue, submitCount, pSubmits, fence);
  23 }
  24
  25 VkResult DeviceDriver::queueWaitIdle (VkQueue queue) const
  26 {
  27         return m_vk.queueWaitIdle(queue);
  28 }
  29
  30 VkResult DeviceDriver::deviceWaitIdle (VkDevice device) const
  31 {
  32         return m_vk.deviceWaitIdle(device);
  33 }
  34
  35 VkResult DeviceDriver::allocateMemory (VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) const
  36 {
  37         return m_vk.allocateMemory(device, pAllocateInfo, pAllocator, pMemory);
  38 }
  39
  40 void DeviceDriver::freeMemory (VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) const
  41 {
  42         m_vk.freeMemory(device, memory, pAllocator);
  43 }
  44
  45 VkResult DeviceDriver::mapMemory (VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const
  46 {
  47         return m_vk.mapMemory(device, memory, offset, size, flags, ppData);
  48 }
  49
  50 void DeviceDriver::unmapMemory (VkDevice device, VkDeviceMemory memory) const
  51 {
  52         m_vk.unmapMemory(device, memory);
  53 }
  54
  55 VkResult DeviceDriver::flushMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const
  56 {
  57         return m_vk.flushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
  58 }
  59
  60 VkResult DeviceDriver::invalidateMappedMemoryRanges (VkDevice device, deUint32 memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const
  61 {
  62         return m_vk.invalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
  63 }
  64
  65 void DeviceDriver::getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const
  66 {
  67         m_vk.getDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
  68 }
  69
  70 VkResult DeviceDriver::bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const
  71 {
  72         return m_vk.bindBufferMemory(device, buffer, memory, memoryOffset);
  73 }
  74
  75 VkResult DeviceDriver::bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const
  76 {
  77         return m_vk.bindImageMemory(device, image, memory, memoryOffset);
  78 }
  79
  80 void DeviceDriver::getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const
  81 {
  82         m_vk.getBufferMemoryRequirements(device, buffer, pMemoryRequirements);
  83 }
  84
  85 void DeviceDriver::getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) const
  86 {
  87         m_vk.getImageMemoryRequirements(device, image, pMemoryRequirements);
  88 }
  89
  90 void DeviceDriver::getImageSparseMemoryRequirements (VkDevice device, VkImage image, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const
  91 {
  92         m_vk.getImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
  93 }
  94
  95 VkResult DeviceDriver::queueBindSparse (VkQueue queue, deUint32 bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) const
  96 {
  97         return m_vk.queueBindSparse(queue, bindInfoCount, pBindInfo, fence);
  98 }
  99
 100 VkResult DeviceDriver::createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const
 101 {
 102         return m_vk.createFence(device, pCreateInfo, pAllocator, pFence);
 103 }
 104
 105 void DeviceDriver::destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) const
 106 {
 107         m_vk.destroyFence(device, fence, pAllocator);
 108 }
 109
 110 VkResult DeviceDriver::resetFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences) const
 111 {
 112         return m_vk.resetFences(device, fenceCount, pFences);
 113 }
 114
 115 VkResult DeviceDriver::getFenceStatus (VkDevice device, VkFence fence) const
 116 {
 117         return m_vk.getFenceStatus(device, fence);
 118 }
 119
 120 VkResult DeviceDriver::waitForFences (VkDevice device, deUint32 fenceCount, const VkFence* pFences, VkBool32 waitAll, deUint64 timeout) const
 121 {
 122         return m_vk.waitForFences(device, fenceCount, pFences, waitAll, timeout);
 123 }
 124
 125 VkResult DeviceDriver::createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) const
 126 {
 127         return m_vk.createSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 128 }
 129
 130 void DeviceDriver::destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) const
 131 {
 132         m_vk.destroySemaphore(device, semaphore, pAllocator);
 133 }
 134
 135 VkResult DeviceDriver::createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) const
 136 {
 137         return m_vk.createEvent(device, pCreateInfo, pAllocator, pEvent);
 138 }
 139
 140 void DeviceDriver::destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) const
 141 {
 142         m_vk.destroyEvent(device, event, pAllocator);
 143 }
 144
 145 VkResult DeviceDriver::getEventStatus (VkDevice device, VkEvent event) const
 146 {
 147         return m_vk.getEventStatus(device, event);
 148 }
 149
 150 VkResult DeviceDriver::setEvent (VkDevice device, VkEvent event) const
 151 {
 152         return m_vk.setEvent(device, event);
 153 }
 154
 155 VkResult DeviceDriver::resetEvent (VkDevice device, VkEvent event) const
 156 {
 157         return m_vk.resetEvent(device, event);
 158 }
 159
 160 VkResult DeviceDriver::createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) const
 161 {
 162         return m_vk.createQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 163 }
 164
 165 void DeviceDriver::destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) const
 166 {
 167         m_vk.destroyQueryPool(device, queryPool, pAllocator);
 168 }
 169
 170 VkResult DeviceDriver::getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const
 171 {
 172         return m_vk.getQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
 173 }
 174
 175 VkResult DeviceDriver::createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) const
 176 {
 177         return m_vk.createBuffer(device, pCreateInfo, pAllocator, pBuffer);
 178 }
 179
 180 void DeviceDriver::destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) const
 181 {
 182         m_vk.destroyBuffer(device, buffer, pAllocator);
 183 }
 184
 185 VkResult DeviceDriver::createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) const
 186 {
 187         return m_vk.createBufferView(device, pCreateInfo, pAllocator, pView);
 188 }
 189
 190 void DeviceDriver::destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) const
 191 {
 192         m_vk.destroyBufferView(device, bufferView, pAllocator);
 193 }
 194
 195 VkResult DeviceDriver::createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) const
 196 {
 197         return m_vk.createImage(device, pCreateInfo, pAllocator, pImage);
 198 }
 199
 200 void DeviceDriver::destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) const
 201 {
 202         m_vk.destroyImage(device, image, pAllocator);
 203 }
 204
 205 void DeviceDriver::getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const
 206 {
 207         m_vk.getImageSubresourceLayout(device, image, pSubresource, pLayout);
 208 }
 209
 210 VkResult DeviceDriver::createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) const
 211 {
 212         return m_vk.createImageView(device, pCreateInfo, pAllocator, pView);
 213 }
 214
 215 void DeviceDriver::destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) const
 216 {
 217         m_vk.destroyImageView(device, imageView, pAllocator);
 218 }
 219
 220 VkResult DeviceDriver::createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) const
 221 {
 222         return m_vk.createShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
 223 }
 224
 225 void DeviceDriver::destroyShaderModule (VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) const
 226 {
 227         m_vk.destroyShaderModule(device, shaderModule, pAllocator);
 228 }
 229
 230 VkResult DeviceDriver::createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) const
 231 {
 232         return m_vk.createPipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 233 }
 234
 235 void DeviceDriver::destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) const
 236 {
 237         m_vk.destroyPipelineCache(device, pipelineCache, pAllocator);
 238 }
 239
 240 VkResult DeviceDriver::getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, deUintptr* pDataSize, void* pData) const
 241 {
 242         return m_vk.getPipelineCacheData(device, pipelineCache, pDataSize, pData);
 243 }
 244
 245 VkResult DeviceDriver::mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, deUint32 srcCacheCount, const VkPipelineCache* pSrcCaches) const
 246 {
 247         return m_vk.mergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
 248 }
 249
 250 VkResult DeviceDriver::createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const
 251 {
 252         return m_vk.createGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 253 }
 254
 255 VkResult DeviceDriver::createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const
 256 {
 257         return m_vk.createComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 258 }
 259
 260 void DeviceDriver::destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) const
 261 {
 262         m_vk.destroyPipeline(device, pipeline, pAllocator);
 263 }
 264
 265 VkResult DeviceDriver::createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) const
 266 {
 267         return m_vk.createPipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 268 }
 269
 270 void DeviceDriver::destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) const
 271 {
 272         m_vk.destroyPipelineLayout(device, pipelineLayout, pAllocator);
 273 }
 274
 275 VkResult DeviceDriver::createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) const
 276 {
 277         return m_vk.createSampler(device, pCreateInfo, pAllocator, pSampler);
 278 }
 279
 280 void DeviceDriver::destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) const
 281 {
 282         m_vk.destroySampler(device, sampler, pAllocator);
 283 }
 284
 285 VkResult DeviceDriver::createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) const
 286 {
 287         return m_vk.createDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 288 }
 289
 290 void DeviceDriver::destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) const
 291 {
 292         m_vk.destroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
 293 }
 294
 295 VkResult DeviceDriver::createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) const
 296 {
 297         return m_vk.createDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 298 }
 299
 300 void DeviceDriver::destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) const
 301 {
 302         m_vk.destroyDescriptorPool(device, descriptorPool, pAllocator);
 303 }
 304
 305 VkResult DeviceDriver::resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const
 306 {
 307         return m_vk.resetDescriptorPool(device, descriptorPool, flags);
 308 }
 309
 310 VkResult DeviceDriver::allocateDescriptorSets (VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) const
 311 {
 312         return m_vk.allocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
 313 }
 314
 315 VkResult DeviceDriver::freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, deUint32 descriptorSetCount, const VkDescriptorSet* pDescriptorSets) const
 316 {
 317         return m_vk.freeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
 318 }
 319
 320 void DeviceDriver::updateDescriptorSets (VkDevice device, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, deUint32 descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) const
 321 {
 322         m_vk.updateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
 323 }
 324
 325 VkResult DeviceDriver::createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) const
 326 {
 327         return m_vk.createFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 328 }
 329
 330 void DeviceDriver::destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) const
 331 {
 332         m_vk.destroyFramebuffer(device, framebuffer, pAllocator);
 333 }
 334
 335 VkResult DeviceDriver::createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const
 336 {
 337         return m_vk.createRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 338 }
 339
 340 void DeviceDriver::destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) const
 341 {
 342         m_vk.destroyRenderPass(device, renderPass, pAllocator);
 343 }
 344
 345 void DeviceDriver::getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const
 346 {
 347         m_vk.getRenderAreaGranularity(device, renderPass, pGranularity);
 348 }
 349
 350 VkResult DeviceDriver::createCommandPool (VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) const
 351 {
 352         return m_vk.createCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
 353 }
 354
 355 void DeviceDriver::destroyCommandPool (VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) const
 356 {
 357         m_vk.destroyCommandPool(device, commandPool, pAllocator);
 358 }
 359
 360 VkResult DeviceDriver::resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) const
 361 {
 362         return m_vk.resetCommandPool(device, commandPool, flags);
 363 }
 364
 365 VkResult DeviceDriver::allocateCommandBuffers (VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) const
 366 {
 367         return m_vk.allocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
 368 }
 369
 370 void DeviceDriver::freeCommandBuffers (VkDevice device, VkCommandPool commandPool, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers) const
 371 {
 372         m_vk.freeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
 373 }
 374
 375 VkResult DeviceDriver::beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) const
 376 {
 377         return m_vk.beginCommandBuffer(commandBuffer, pBeginInfo);
 378 }
 379
 380 VkResult DeviceDriver::endCommandBuffer (VkCommandBuffer commandBuffer) const
 381 {
 382         return m_vk.endCommandBuffer(commandBuffer);
 383 }
 384
 385 VkResult DeviceDriver::resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const
 386 {
 387         return m_vk.resetCommandBuffer(commandBuffer, flags);
 388 }
 389
 390 void DeviceDriver::cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const
 391 {
 392         m_vk.cmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 393 }
 394
 395 void DeviceDriver::cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports) const
 396 {
 397         m_vk.cmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
 398 }
 399
 400 void DeviceDriver::cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors) const
 401 {
 402         m_vk.cmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
 403 }
 404
 405 void DeviceDriver::cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) const
 406 {
 407         m_vk.cmdSetLineWidth(commandBuffer, lineWidth);
 408 }
 409
 410 void DeviceDriver::cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const
 411 {
 412         m_vk.cmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 413 }
 414
 415 void DeviceDriver::cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4]) const
 416 {
 417         m_vk.cmdSetBlendConstants(commandBuffer, blendConstants);
 418 }
 419
 420 void DeviceDriver::cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const
 421 {
 422         m_vk.cmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 423 }
 424
 425 void DeviceDriver::cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 compareMask) const
 426 {
 427         m_vk.cmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 428 }
 429
 430 void DeviceDriver::cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 writeMask) const
 431 {
 432         m_vk.cmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 433 }
 434
 435 void DeviceDriver::cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 reference) const
 436 {
 437         m_vk.cmdSetStencilReference(commandBuffer, faceMask, reference);
 438 }
 439
 440 void DeviceDriver::cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 descriptorSetCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const
 441 {
 442         m_vk.cmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 443 }
 444
 445 void DeviceDriver::cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const
 446 {
 447         m_vk.cmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 448 }
 449
 450 void DeviceDriver::cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const
 451 {
 452         m_vk.cmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
 453 }
 454
 455 void DeviceDriver::cmdDraw (VkCommandBuffer commandBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance) const
 456 {
 457         m_vk.cmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 458 }
 459
 460 void DeviceDriver::cmdDrawIndexed (VkCommandBuffer commandBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance) const
 461 {
 462         m_vk.cmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 463 }
 464
 465 void DeviceDriver::cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride) const
 466 {
 467         m_vk.cmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
 468 }
 469
 470 void DeviceDriver::cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride) const
 471 {
 472         m_vk.cmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
 473 }
 474
 475 void DeviceDriver::cmdDispatch (VkCommandBuffer commandBuffer, deUint32 groupCountX, deUint32 groupCountY, deUint32 groupCountZ) const
 476 {
 477         m_vk.cmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
 478 }
 479
 480 void DeviceDriver::cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const
 481 {
 482         m_vk.cmdDispatchIndirect(commandBuffer, buffer, offset);
 483 }
 484
 485 void DeviceDriver::cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferCopy* pRegions) const
 486 {
 487         m_vk.cmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 488 }
 489
 490 void DeviceDriver::cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageCopy* pRegions) const
 491 {
 492         m_vk.cmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 493 }
 494
 495 void DeviceDriver::cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageBlit* pRegions, VkFilter filter) const
 496 {
 497         m_vk.cmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 498 }
 499
 500 void DeviceDriver::cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkBufferImageCopy* pRegions) const
 501 {
 502         m_vk.cmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 503 }
 504
 505 void DeviceDriver::cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, deUint32 regionCount, const VkBufferImageCopy* pRegions) const
 506 {
 507         m_vk.cmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 508 }
 509
 510 void DeviceDriver::cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) const
 511 {
 512         m_vk.cmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 513 }
 514
 515 void DeviceDriver::cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, deUint32 data) const
 516 {
 517         m_vk.cmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 518 }
 519
 520 void DeviceDriver::cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
 521 {
 522         m_vk.cmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 523 }
 524
 525 void DeviceDriver::cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, deUint32 rangeCount, const VkImageSubresourceRange* pRanges) const
 526 {
 527         m_vk.cmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 528 }
 529
 530 void DeviceDriver::cmdClearAttachments (VkCommandBuffer commandBuffer, deUint32 attachmentCount, const VkClearAttachment* pAttachments, deUint32 rectCount, const VkClearRect* pRects) const
 531 {
 532         m_vk.cmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 533 }
 534
 535 void DeviceDriver::cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const
 536 {
 537         m_vk.cmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 538 }
 539
 540 void DeviceDriver::cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const
 541 {
 542         m_vk.cmdSetEvent(commandBuffer, event, stageMask);
 543 }
 544
 545 void DeviceDriver::cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const
 546 {
 547         m_vk.cmdResetEvent(commandBuffer, event, stageMask);
 548 }
 549
 550 void DeviceDriver::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) const
 551 {
 552         m_vk.cmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 553 }
 554
 555 void DeviceDriver::cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const
 556 {
 557         m_vk.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 558 }
 559
 560 void DeviceDriver::cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags) const
 561 {
 562         m_vk.cmdBeginQuery(commandBuffer, queryPool, query, flags);
 563 }
 564
 565 void DeviceDriver::cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query) const
 566 {
 567         m_vk.cmdEndQuery(commandBuffer, queryPool, query);
 568 }
 569
 570 void DeviceDriver::cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount) const
 571 {
 572         m_vk.cmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
 573 }
 574
 575 void DeviceDriver::cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query) const
 576 {
 577         m_vk.cmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
 578 }
 579
 580 void DeviceDriver::cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const
 581 {
 582         m_vk.cmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 583 }
 584
 585 void DeviceDriver::cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 offset, deUint32 size, const void* pValues) const
 586 {
 587         m_vk.cmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
 588 }
 589
 590 void DeviceDriver::cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) const
 591 {
 592         m_vk.cmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 593 }
 594
 595 void DeviceDriver::cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents) const
 596 {
 597         m_vk.cmdNextSubpass(commandBuffer, contents);
 598 }
 599
 600 void DeviceDriver::cmdEndRenderPass (VkCommandBuffer commandBuffer) const
 601 {
 602         m_vk.cmdEndRenderPass(commandBuffer);
 603 }
 604
 605 void DeviceDriver::cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers) const
 606 {
 607         m_vk.cmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
 608 }
 609
 610 VkResult DeviceDriver::bindBufferMemory2 (VkDevice device, deUint32 bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const
 611 {
 612         return m_vk.bindBufferMemory2(device, bindInfoCount, pBindInfos);
 613 }
 614
 615 VkResult DeviceDriver::bindImageMemory2 (VkDevice device, deUint32 bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const
 616 {
 617         return m_vk.bindImageMemory2(device, bindInfoCount, pBindInfos);
 618 }
 619
 620 void DeviceDriver::getDeviceGroupPeerMemoryFeatures (VkDevice device, deUint32 heapIndex, deUint32 localDeviceIndex, deUint32 remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const
 621 {
 622         m_vk.getDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
 623 }
 624
 625 void DeviceDriver::cmdSetDeviceMask (VkCommandBuffer commandBuffer, deUint32 deviceMask) const
 626 {
 627         m_vk.cmdSetDeviceMask(commandBuffer, deviceMask);
 628 }
 629
 630 void DeviceDriver::cmdDispatchBase (VkCommandBuffer commandBuffer, deUint32 baseGroupX, deUint32 baseGroupY, deUint32 baseGroupZ, deUint32 groupCountX, deUint32 groupCountY, deUint32 groupCountZ) const
 631 {
 632         m_vk.cmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
 633 }
 634
 635 void DeviceDriver::getImageMemoryRequirements2 (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const
 636 {
 637         m_vk.getImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
 638 }
 639
 640 void DeviceDriver::getBufferMemoryRequirements2 (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const
 641 {
 642         m_vk.getBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
 643 }
 644
 645 void DeviceDriver::getImageSparseMemoryRequirements2 (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const
 646 {
 647         m_vk.getImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 648 }
 649
 650 void DeviceDriver::trimCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const
 651 {
 652         m_vk.trimCommandPool(device, commandPool, flags);
 653 }
 654
 655 void DeviceDriver::getDeviceQueue2 (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const
 656 {
 657         m_vk.getDeviceQueue2(device, pQueueInfo, pQueue);
 658 }
 659
 660 VkResult DeviceDriver::createSamplerYcbcrConversion (VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const
 661 {
 662         return m_vk.createSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
 663 }
 664
 665 void DeviceDriver::destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const
 666 {
 667         m_vk.destroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
 668 }
 669
 670 VkResult DeviceDriver::createDescriptorUpdateTemplate (VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) const
 671 {
 672         return m_vk.createDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
 673 }
 674
 675 void DeviceDriver::destroyDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const
 676 {
 677         m_vk.destroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
 678 }
 679
 680 void DeviceDriver::updateDescriptorSetWithTemplate (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) const
 681 {
 682         m_vk.updateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
 683 }
 684
 685 void DeviceDriver::getDescriptorSetLayoutSupport (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const
 686 {
 687         m_vk.getDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
 688 }
 689
 690 VkResult DeviceDriver::createSwapchainKHR (VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) const
 691 {
 692         return m_vk.createSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
 693 }
 694
 695 void DeviceDriver::destroySwapchainKHR (VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) const
 696 {
 697         m_vk.destroySwapchainKHR(device, swapchain, pAllocator);
 698 }
 699
 700 VkResult DeviceDriver::getSwapchainImagesKHR (VkDevice device, VkSwapchainKHR swapchain, deUint32* pSwapchainImageCount, VkImage* pSwapchainImages) const
 701 {
 702         return m_vk.getSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
 703 }
 704
 705 VkResult DeviceDriver::acquireNextImageKHR (VkDevice device, VkSwapchainKHR swapchain, deUint64 timeout, VkSemaphore semaphore, VkFence fence, deUint32* pImageIndex) const
 706 {
 707         return m_vk.acquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
 708 }
 709
 710 VkResult DeviceDriver::queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const
 711 {
 712         return m_vk.queuePresentKHR(queue, pPresentInfo);
 713 }
 714
 715 VkResult DeviceDriver::getDeviceGroupPresentCapabilitiesKHR (VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) const
 716 {
 717         return m_vk.getDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
 718 }
 719
 720 VkResult DeviceDriver::getDeviceGroupSurfacePresentModesKHR (VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) const
 721 {
 722         return m_vk.getDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
 723 }
 724
 725 VkResult DeviceDriver::acquireNextImage2KHR (VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, deUint32* pImageIndex) const
 726 {
 727         return m_vk.acquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
 728 }
 729
 730 VkResult DeviceDriver::createSharedSwapchainsKHR (VkDevice device, deUint32 swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const
 731 {
 732         return m_vk.createSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
 733 }
 734
 735 VkResult DeviceDriver::getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const
 736 {
 737         return m_vk.getMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
 738 }
 739
 740 VkResult DeviceDriver::getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) const
 741 {
 742         return m_vk.getMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
 743 }
 744
 745 VkResult DeviceDriver::getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const
 746 {
 747         return m_vk.getMemoryFdKHR(device, pGetFdInfo, pFd);
 748 }
 749
 750 VkResult DeviceDriver::getMemoryFdPropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) const
 751 {
 752         return m_vk.getMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
 753 }
 754
 755 VkResult DeviceDriver::importSemaphoreWin32HandleKHR (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) const
 756 {
 757         return m_vk.importSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
 758 }
 759
 760 VkResult DeviceDriver::getSemaphoreWin32HandleKHR (VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const
 761 {
 762         return m_vk.getSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
 763 }
 764
 765 VkResult DeviceDriver::importSemaphoreFdKHR (VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) const
 766 {
 767         return m_vk.importSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
 768 }
 769
 770 VkResult DeviceDriver::getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) const
 771 {
 772         return m_vk.getSemaphoreFdKHR(device, pGetFdInfo, pFd);
 773 }
 774
 775 void DeviceDriver::cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const
 776 {
 777         m_vk.cmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
 778 }
 779
 780 void DeviceDriver::cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData) const
 781 {
 782         m_vk.cmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
 783 }
 784
 785 VkResult DeviceDriver::getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const
 786 {
 787         return m_vk.getSwapchainStatusKHR(device, swapchain);
 788 }
 789
 790 VkResult DeviceDriver::importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) const
 791 {
 792         return m_vk.importFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
 793 }
 794
 795 VkResult DeviceDriver::getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const
 796 {
 797         return m_vk.getFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
 798 }
 799
 800 VkResult DeviceDriver::importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const
 801 {
 802         return m_vk.importFenceFdKHR(device, pImportFenceFdInfo);
 803 }
 804
 805 VkResult DeviceDriver::getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const
 806 {
 807         return m_vk.getFenceFdKHR(device, pGetFdInfo, pFd);
 808 }
 809
 810 VkResult DeviceDriver::debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const
 811 {
 812         return m_vk.debugMarkerSetObjectTagEXT(device, pTagInfo);
 813 }
 814
 815 VkResult DeviceDriver::debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const
 816 {
 817         return m_vk.debugMarkerSetObjectNameEXT(device, pNameInfo);
 818 }
 819
 820 void DeviceDriver::cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const
 821 {
 822         m_vk.cmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
 823 }
 824
 825 void DeviceDriver::cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer) const
 826 {
 827         m_vk.cmdDebugMarkerEndEXT(commandBuffer);
 828 }
 829
 830 void DeviceDriver::cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const
 831 {
 832         m_vk.cmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
 833 }
 834
 835 void DeviceDriver::cmdDrawIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const
 836 {
 837         m_vk.cmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 838 }
 839
 840 void DeviceDriver::cmdDrawIndexedIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const
 841 {
 842         m_vk.cmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 843 }
 844
 845 void DeviceDriver::cmdDrawIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const
 846 {
 847         m_vk.cmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 848 }
 849
 850 void DeviceDriver::cmdDrawIndexedIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const
 851 {
 852         m_vk.cmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 853 }
 854
 855 VkResult DeviceDriver::getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle) const
 856 {
 857         return m_vk.getMemoryWin32HandleNV(device, memory, handleType, pHandle);
 858 }
 859
 860 void DeviceDriver::cmdProcessCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) const
 861 {
 862         m_vk.cmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
 863 }
 864
 865 void DeviceDriver::cmdReserveSpaceForCommandsNVX (VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) const
 866 {
 867         m_vk.cmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
 868 }
 869
 870 VkResult DeviceDriver::createIndirectCommandsLayoutNVX (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) const
 871 {
 872         return m_vk.createIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
 873 }
 874
 875 void DeviceDriver::destroyIndirectCommandsLayoutNVX (VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) const
 876 {
 877         m_vk.destroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
 878 }
 879
 880 VkResult DeviceDriver::createObjectTableNVX (VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable) const
 881 {
 882         return m_vk.createObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
 883 }
 884
 885 void DeviceDriver::destroyObjectTableNVX (VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) const
 886 {
 887         m_vk.destroyObjectTableNVX(device, objectTable, pAllocator);
 888 }
 889
 890 VkResult DeviceDriver::registerObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const deUint32* pObjectIndices) const
 891 {
 892         return m_vk.registerObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
 893 }
 894
 895 VkResult DeviceDriver::unregisterObjectsNVX (VkDevice device, VkObjectTableNVX objectTable, deUint32 objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const deUint32* pObjectIndices) const
 896 {
 897         return m_vk.unregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
 898 }
 899
 900 void DeviceDriver::cmdSetViewportWScalingNV (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewportWScalingNV* pViewportWScalings) const
 901 {
 902         m_vk.cmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
 903 }
 904
 905 VkResult DeviceDriver::displayPowerControlEXT (VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) const
 906 {
 907         return m_vk.displayPowerControlEXT(device, display, pDisplayPowerInfo);
 908 }
 909
 910 VkResult DeviceDriver::registerDeviceEventEXT (VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const
 911 {
 912         return m_vk.registerDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
 913 }
 914
 915 VkResult DeviceDriver::registerDisplayEventEXT (VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const
 916 {
 917         return m_vk.registerDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
 918 }
 919
 920 VkResult DeviceDriver::getSwapchainCounterEXT (VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, deUint64* pCounterValue) const
 921 {
 922         return m_vk.getSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
 923 }
 924
 925 VkResult DeviceDriver::getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const
 926 {
 927         return m_vk.getRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
 928 }
 929
 930 VkResult DeviceDriver::getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, deUint32* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) const
 931 {
 932         return m_vk.getPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
 933 }
 934
 935 void DeviceDriver::cmdSetDiscardRectangleEXT (VkCommandBuffer commandBuffer, deUint32 firstDiscardRectangle, deUint32 discardRectangleCount, const VkRect2D* pDiscardRectangles) const
 936 {
 937         m_vk.cmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
 938 }
 939
 940 void DeviceDriver::setHdrMetadataEXT (VkDevice device, deUint32 swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) const
 941 {
 942         m_vk.setHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
 943 }
 944
 945 void DeviceDriver::cmdSetSampleLocationsEXT (VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) const
 946 {
 947         m_vk.cmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
 948 }
 949
 950 VkResult DeviceDriver::createValidationCacheEXT (VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) const
 951 {
 952         return m_vk.createValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
 953 }
 954
 955 void DeviceDriver::destroyValidationCacheEXT (VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) const
 956 {
 957         m_vk.destroyValidationCacheEXT(device, validationCache, pAllocator);
 958 }
 959
 960 VkResult DeviceDriver::mergeValidationCachesEXT (VkDevice device, VkValidationCacheEXT dstCache, deUint32 srcCacheCount, const VkValidationCacheEXT* pSrcCaches) const
 961 {
 962         return m_vk.mergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
 963 }
 964
 965 VkResult DeviceDriver::getValidationCacheDataEXT (VkDevice device, VkValidationCacheEXT validationCache, deUintptr* pDataSize, void* pData) const
 966 {
 967         return m_vk.getValidationCacheDataEXT(device, validationCache, pDataSize, pData);
 968 }
 969
 970 VkResult DeviceDriver::getMemoryAndroidHardwareBufferPropertiesANDROID (VkDevice device, const pt::AndroidHardwareBufferPtr buffer, VkMemoryAndroidHardwareBufferPropertiesANDROID* pProperties) const
 971 {
 972         return m_vk.getMemoryAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
 973 }
 974
 975 VkResult DeviceDriver::getMemoryAndroidHardwareBufferANDROID (VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, pt::AndroidHardwareBufferPtr* pBuffer) const
 976 {
 977         return m_vk.getMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
 978 }