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  * This file was generated by /scripts/gen_framework.py
   4  */
   5
   6 PFN_vkVoidFunction DeviceDriver::getDeviceProcAddr (VkDevice device, const char* pName) const
   7 {
   8         return m_vk.getDeviceProcAddr(device, pName);
   9 }
  10
  11 void DeviceDriver::destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator) const
  12 {
  13         m_vk.destroyDevice(device, pAllocator);
  14 }
  15
  16 void DeviceDriver::getDeviceQueue (VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) const
  17 {
  18         m_vk.getDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
  19 }
  20
  21 VkResult DeviceDriver::queueSubmit (VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) const
  22 {
  23         return m_vk.queueSubmit(queue, submitCount, pSubmits, fence);
  24 }
  25
  26 VkResult DeviceDriver::queueWaitIdle (VkQueue queue) const
  27 {
  28         return m_vk.queueWaitIdle(queue);
  29 }
  30
  31 VkResult DeviceDriver::deviceWaitIdle (VkDevice device) const
  32 {
  33         return m_vk.deviceWaitIdle(device);
  34 }
  35
  36 VkResult DeviceDriver::allocateMemory (VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) const
  37 {
  38         return m_vk.allocateMemory(device, pAllocateInfo, pAllocator, pMemory);
  39 }
  40
  41 void DeviceDriver::freeMemory (VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) const
  42 {
  43         m_vk.freeMemory(device, memory, pAllocator);
  44 }
  45
  46 VkResult DeviceDriver::mapMemory (VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const
  47 {
  48         return m_vk.mapMemory(device, memory, offset, size, flags, ppData);
  49 }
  50
  51 void DeviceDriver::unmapMemory (VkDevice device, VkDeviceMemory memory) const
  52 {
  53         m_vk.unmapMemory(device, memory);
  54 }
  55
  56 VkResult DeviceDriver::flushMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const
  57 {
  58         return m_vk.flushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
  59 }
  60
  61 VkResult DeviceDriver::invalidateMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const
  62 {
  63         return m_vk.invalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
  64 }
  65
  66 void DeviceDriver::getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const
  67 {
  68         m_vk.getDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
  69 }
  70
  71 VkResult DeviceDriver::bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const
  72 {
  73         return m_vk.bindBufferMemory(device, buffer, memory, memoryOffset);
  74 }
  75
  76 VkResult DeviceDriver::bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const
  77 {
  78         return m_vk.bindImageMemory(device, image, memory, memoryOffset);
  79 }
  80
  81 void DeviceDriver::getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const
  82 {
  83         m_vk.getBufferMemoryRequirements(device, buffer, pMemoryRequirements);
  84 }
  85
  86 void DeviceDriver::getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) const
  87 {
  88         m_vk.getImageMemoryRequirements(device, image, pMemoryRequirements);
  89 }
  90
  91 void DeviceDriver::getImageSparseMemoryRequirements (VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const
  92 {
  93         m_vk.getImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
  94 }
  95
  96 VkResult DeviceDriver::queueBindSparse (VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) const
  97 {
  98         return m_vk.queueBindSparse(queue, bindInfoCount, pBindInfo, fence);
  99 }
 100
 101 VkResult DeviceDriver::createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const
 102 {
 103         return m_vk.createFence(device, pCreateInfo, pAllocator, pFence);
 104 }
 105
 106 void DeviceDriver::destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) const
 107 {
 108         m_vk.destroyFence(device, fence, pAllocator);
 109 }
 110
 111 VkResult DeviceDriver::resetFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences) const
 112 {
 113         return m_vk.resetFences(device, fenceCount, pFences);
 114 }
 115
 116 VkResult DeviceDriver::getFenceStatus (VkDevice device, VkFence fence) const
 117 {
 118         return m_vk.getFenceStatus(device, fence);
 119 }
 120
 121 VkResult DeviceDriver::waitForFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) const
 122 {
 123         return m_vk.waitForFences(device, fenceCount, pFences, waitAll, timeout);
 124 }
 125
 126 VkResult DeviceDriver::createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) const
 127 {
 128         return m_vk.createSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 129 }
 130
 131 void DeviceDriver::destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) const
 132 {
 133         m_vk.destroySemaphore(device, semaphore, pAllocator);
 134 }
 135
 136 VkResult DeviceDriver::createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) const
 137 {
 138         return m_vk.createEvent(device, pCreateInfo, pAllocator, pEvent);
 139 }
 140
 141 void DeviceDriver::destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) const
 142 {
 143         m_vk.destroyEvent(device, event, pAllocator);
 144 }
 145
 146 VkResult DeviceDriver::getEventStatus (VkDevice device, VkEvent event) const
 147 {
 148         return m_vk.getEventStatus(device, event);
 149 }
 150
 151 VkResult DeviceDriver::setEvent (VkDevice device, VkEvent event) const
 152 {
 153         return m_vk.setEvent(device, event);
 154 }
 155
 156 VkResult DeviceDriver::resetEvent (VkDevice device, VkEvent event) const
 157 {
 158         return m_vk.resetEvent(device, event);
 159 }
 160
 161 VkResult DeviceDriver::createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) const
 162 {
 163         return m_vk.createQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 164 }
 165
 166 void DeviceDriver::destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) const
 167 {
 168         m_vk.destroyQueryPool(device, queryPool, pAllocator);
 169 }
 170
 171 VkResult DeviceDriver::getQueryPoolResults (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const
 172 {
 173         return m_vk.getQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
 174 }
 175
 176 VkResult DeviceDriver::createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) const
 177 {
 178         return m_vk.createBuffer(device, pCreateInfo, pAllocator, pBuffer);
 179 }
 180
 181 void DeviceDriver::destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) const
 182 {
 183         m_vk.destroyBuffer(device, buffer, pAllocator);
 184 }
 185
 186 VkResult DeviceDriver::createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) const
 187 {
 188         return m_vk.createBufferView(device, pCreateInfo, pAllocator, pView);
 189 }
 190
 191 void DeviceDriver::destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) const
 192 {
 193         m_vk.destroyBufferView(device, bufferView, pAllocator);
 194 }
 195
 196 VkResult DeviceDriver::createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) const
 197 {
 198         return m_vk.createImage(device, pCreateInfo, pAllocator, pImage);
 199 }
 200
 201 void DeviceDriver::destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) const
 202 {
 203         m_vk.destroyImage(device, image, pAllocator);
 204 }
 205
 206 void DeviceDriver::getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const
 207 {
 208         m_vk.getImageSubresourceLayout(device, image, pSubresource, pLayout);
 209 }
 210
 211 VkResult DeviceDriver::createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) const
 212 {
 213         return m_vk.createImageView(device, pCreateInfo, pAllocator, pView);
 214 }
 215
 216 void DeviceDriver::destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) const
 217 {
 218         m_vk.destroyImageView(device, imageView, pAllocator);
 219 }
 220
 221 VkResult DeviceDriver::createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) const
 222 {
 223         return m_vk.createShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
 224 }
 225
 226 void DeviceDriver::destroyShaderModule (VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) const
 227 {
 228         m_vk.destroyShaderModule(device, shaderModule, pAllocator);
 229 }
 230
 231 VkResult DeviceDriver::createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) const
 232 {
 233         return m_vk.createPipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 234 }
 235
 236 void DeviceDriver::destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) const
 237 {
 238         m_vk.destroyPipelineCache(device, pipelineCache, pAllocator);
 239 }
 240
 241 VkResult DeviceDriver::getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) const
 242 {
 243         return m_vk.getPipelineCacheData(device, pipelineCache, pDataSize, pData);
 244 }
 245
 246 VkResult DeviceDriver::mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) const
 247 {
 248         return m_vk.mergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
 249 }
 250
 251 VkResult DeviceDriver::createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const
 252 {
 253         return m_vk.createGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 254 }
 255
 256 VkResult DeviceDriver::createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const
 257 {
 258         return m_vk.createComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 259 }
 260
 261 void DeviceDriver::destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) const
 262 {
 263         m_vk.destroyPipeline(device, pipeline, pAllocator);
 264 }
 265
 266 VkResult DeviceDriver::createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) const
 267 {
 268         return m_vk.createPipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 269 }
 270
 271 void DeviceDriver::destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) const
 272 {
 273         m_vk.destroyPipelineLayout(device, pipelineLayout, pAllocator);
 274 }
 275
 276 VkResult DeviceDriver::createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) const
 277 {
 278         return m_vk.createSampler(device, pCreateInfo, pAllocator, pSampler);
 279 }
 280
 281 void DeviceDriver::destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) const
 282 {
 283         m_vk.destroySampler(device, sampler, pAllocator);
 284 }
 285
 286 VkResult DeviceDriver::createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) const
 287 {
 288         return m_vk.createDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 289 }
 290
 291 void DeviceDriver::destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) const
 292 {
 293         m_vk.destroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
 294 }
 295
 296 VkResult DeviceDriver::createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) const
 297 {
 298         return m_vk.createDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 299 }
 300
 301 void DeviceDriver::destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) const
 302 {
 303         m_vk.destroyDescriptorPool(device, descriptorPool, pAllocator);
 304 }
 305
 306 VkResult DeviceDriver::resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const
 307 {
 308         return m_vk.resetDescriptorPool(device, descriptorPool, flags);
 309 }
 310
 311 VkResult DeviceDriver::allocateDescriptorSets (VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) const
 312 {
 313         return m_vk.allocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
 314 }
 315
 316 VkResult DeviceDriver::freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) const
 317 {
 318         return m_vk.freeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
 319 }
 320
 321 void DeviceDriver::updateDescriptorSets (VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) const
 322 {
 323         m_vk.updateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
 324 }
 325
 326 VkResult DeviceDriver::createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) const
 327 {
 328         return m_vk.createFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 329 }
 330
 331 void DeviceDriver::destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) const
 332 {
 333         m_vk.destroyFramebuffer(device, framebuffer, pAllocator);
 334 }
 335
 336 VkResult DeviceDriver::createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const
 337 {
 338         return m_vk.createRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 339 }
 340
 341 void DeviceDriver::destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) const
 342 {
 343         m_vk.destroyRenderPass(device, renderPass, pAllocator);
 344 }
 345
 346 void DeviceDriver::getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const
 347 {
 348         m_vk.getRenderAreaGranularity(device, renderPass, pGranularity);
 349 }
 350
 351 VkResult DeviceDriver::createCommandPool (VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) const
 352 {
 353         return m_vk.createCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
 354 }
 355
 356 void DeviceDriver::destroyCommandPool (VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) const
 357 {
 358         m_vk.destroyCommandPool(device, commandPool, pAllocator);
 359 }
 360
 361 VkResult DeviceDriver::resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) const
 362 {
 363         return m_vk.resetCommandPool(device, commandPool, flags);
 364 }
 365
 366 VkResult DeviceDriver::allocateCommandBuffers (VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) const
 367 {
 368         return m_vk.allocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
 369 }
 370
 371 void DeviceDriver::freeCommandBuffers (VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const
 372 {
 373         m_vk.freeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
 374 }
 375
 376 VkResult DeviceDriver::beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) const
 377 {
 378         return m_vk.beginCommandBuffer(commandBuffer, pBeginInfo);
 379 }
 380
 381 VkResult DeviceDriver::endCommandBuffer (VkCommandBuffer commandBuffer) const
 382 {
 383         return m_vk.endCommandBuffer(commandBuffer);
 384 }
 385
 386 VkResult DeviceDriver::resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const
 387 {
 388         return m_vk.resetCommandBuffer(commandBuffer, flags);
 389 }
 390
 391 void DeviceDriver::cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const
 392 {
 393         m_vk.cmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 394 }
 395
 396 void DeviceDriver::cmdSetViewport (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) const
 397 {
 398         m_vk.cmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
 399 }
 400
 401 void DeviceDriver::cmdSetScissor (VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) const
 402 {
 403         m_vk.cmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
 404 }
 405
 406 void DeviceDriver::cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) const
 407 {
 408         m_vk.cmdSetLineWidth(commandBuffer, lineWidth);
 409 }
 410
 411 void DeviceDriver::cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const
 412 {
 413         m_vk.cmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 414 }
 415
 416 void DeviceDriver::cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4]) const
 417 {
 418         m_vk.cmdSetBlendConstants(commandBuffer, blendConstants);
 419 }
 420
 421 void DeviceDriver::cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const
 422 {
 423         m_vk.cmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 424 }
 425
 426 void DeviceDriver::cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const
 427 {
 428         m_vk.cmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 429 }
 430
 431 void DeviceDriver::cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const
 432 {
 433         m_vk.cmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 434 }
 435
 436 void DeviceDriver::cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const
 437 {
 438         m_vk.cmdSetStencilReference(commandBuffer, faceMask, reference);
 439 }
 440
 441 void DeviceDriver::cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) const
 442 {
 443         m_vk.cmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 444 }
 445
 446 void DeviceDriver::cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const
 447 {
 448         m_vk.cmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 449 }
 450
 451 void DeviceDriver::cmdBindVertexBuffers (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const
 452 {
 453         m_vk.cmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
 454 }
 455
 456 void DeviceDriver::cmdDraw (VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const
 457 {
 458         m_vk.cmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 459 }
 460
 461 void DeviceDriver::cmdDrawIndexed (VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const
 462 {
 463         m_vk.cmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 464 }
 465
 466 void DeviceDriver::cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
 467 {
 468         m_vk.cmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
 469 }
 470
 471 void DeviceDriver::cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
 472 {
 473         m_vk.cmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
 474 }
 475
 476 void DeviceDriver::cmdDispatch (VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const
 477 {
 478         m_vk.cmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
 479 }
 480
 481 void DeviceDriver::cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const
 482 {
 483         m_vk.cmdDispatchIndirect(commandBuffer, buffer, offset);
 484 }
 485
 486 void DeviceDriver::cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) const
 487 {
 488         m_vk.cmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 489 }
 490
 491 void DeviceDriver::cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) const
 492 {
 493         m_vk.cmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 494 }
 495
 496 void DeviceDriver::cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) const
 497 {
 498         m_vk.cmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 499 }
 500
 501 void DeviceDriver::cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) const
 502 {
 503         m_vk.cmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 504 }
 505
 506 void DeviceDriver::cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) const
 507 {
 508         m_vk.cmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 509 }
 510
 511 void DeviceDriver::cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) const
 512 {
 513         m_vk.cmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 514 }
 515
 516 void DeviceDriver::cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const
 517 {
 518         m_vk.cmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 519 }
 520
 521 void DeviceDriver::cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const
 522 {
 523         m_vk.cmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 524 }
 525
 526 void DeviceDriver::cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const
 527 {
 528         m_vk.cmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 529 }
 530
 531 void DeviceDriver::cmdClearAttachments (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) const
 532 {
 533         m_vk.cmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 534 }
 535
 536 void DeviceDriver::cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) const
 537 {
 538         m_vk.cmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 539 }
 540
 541 void DeviceDriver::cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const
 542 {
 543         m_vk.cmdSetEvent(commandBuffer, event, stageMask);
 544 }
 545
 546 void DeviceDriver::cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const
 547 {
 548         m_vk.cmdResetEvent(commandBuffer, event, stageMask);
 549 }
 550
 551 void DeviceDriver::cmdWaitEvents (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const
 552 {
 553         m_vk.cmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 554 }
 555
 556 void DeviceDriver::cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const
 557 {
 558         m_vk.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 559 }
 560
 561 void DeviceDriver::cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const
 562 {
 563         m_vk.cmdBeginQuery(commandBuffer, queryPool, query, flags);
 564 }
 565
 566 void DeviceDriver::cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const
 567 {
 568         m_vk.cmdEndQuery(commandBuffer, queryPool, query);
 569 }
 570
 571 void DeviceDriver::cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const
 572 {
 573         m_vk.cmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
 574 }
 575
 576 void DeviceDriver::cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) const
 577 {
 578         m_vk.cmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
 579 }
 580
 581 void DeviceDriver::cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const
 582 {
 583         m_vk.cmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 584 }
 585
 586 void DeviceDriver::cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) const
 587 {
 588         m_vk.cmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
 589 }
 590
 591 void DeviceDriver::cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) const
 592 {
 593         m_vk.cmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 594 }
 595
 596 void DeviceDriver::cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents) const
 597 {
 598         m_vk.cmdNextSubpass(commandBuffer, contents);
 599 }
 600
 601 void DeviceDriver::cmdEndRenderPass (VkCommandBuffer commandBuffer) const
 602 {
 603         m_vk.cmdEndRenderPass(commandBuffer);
 604 }
 605
 606 void DeviceDriver::cmdExecuteCommands (VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const
 607 {
 608         m_vk.cmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
 609 }
 610
 611 VkResult DeviceDriver::bindBufferMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const
 612 {
 613         return m_vk.bindBufferMemory2(device, bindInfoCount, pBindInfos);
 614 }
 615
 616 VkResult DeviceDriver::bindImageMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const
 617 {
 618         return m_vk.bindImageMemory2(device, bindInfoCount, pBindInfos);
 619 }
 620
 621 void DeviceDriver::getDeviceGroupPeerMemoryFeatures (VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const
 622 {
 623         m_vk.getDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
 624 }
 625
 626 void DeviceDriver::cmdSetDeviceMask (VkCommandBuffer commandBuffer, uint32_t deviceMask) const
 627 {
 628         m_vk.cmdSetDeviceMask(commandBuffer, deviceMask);
 629 }
 630
 631 void DeviceDriver::cmdDispatchBase (VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const
 632 {
 633         m_vk.cmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
 634 }
 635
 636 void DeviceDriver::getImageMemoryRequirements2 (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const
 637 {
 638         m_vk.getImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
 639 }
 640
 641 void DeviceDriver::getBufferMemoryRequirements2 (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const
 642 {
 643         m_vk.getBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
 644 }
 645
 646 void DeviceDriver::getImageSparseMemoryRequirements2 (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const
 647 {
 648         m_vk.getImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 649 }
 650
 651 void DeviceDriver::trimCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const
 652 {
 653         m_vk.trimCommandPool(device, commandPool, flags);
 654 }
 655
 656 void DeviceDriver::getDeviceQueue2 (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const
 657 {
 658         m_vk.getDeviceQueue2(device, pQueueInfo, pQueue);
 659 }
 660
 661 VkResult DeviceDriver::createSamplerYcbcrConversion (VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const
 662 {
 663         return m_vk.createSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
 664 }
 665
 666 void DeviceDriver::destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const
 667 {
 668         m_vk.destroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
 669 }
 670
 671 VkResult DeviceDriver::createDescriptorUpdateTemplate (VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) const
 672 {
 673         return m_vk.createDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
 674 }
 675
 676 void DeviceDriver::destroyDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const
 677 {
 678         m_vk.destroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
 679 }
 680
 681 void DeviceDriver::updateDescriptorSetWithTemplate (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) const
 682 {
 683         m_vk.updateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
 684 }
 685
 686 void DeviceDriver::getDescriptorSetLayoutSupport (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const
 687 {
 688         m_vk.getDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
 689 }
 690
 691 void DeviceDriver::cmdDrawIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
 692 {
 693         m_vk.cmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 694 }
 695
 696 void DeviceDriver::cmdDrawIndexedIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
 697 {
 698         m_vk.cmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 699 }
 700
 701 VkResult DeviceDriver::createRenderPass2 (VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const
 702 {
 703         return m_vk.createRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
 704 }
 705
 706 void DeviceDriver::cmdBeginRenderPass2 (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) const
 707 {
 708         m_vk.cmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
 709 }
 710
 711 void DeviceDriver::cmdNextSubpass2 (VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) const
 712 {
 713         m_vk.cmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
 714 }
 715
 716 void DeviceDriver::cmdEndRenderPass2 (VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) const
 717 {
 718         m_vk.cmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
 719 }
 720
 721 void DeviceDriver::resetQueryPool (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const
 722 {
 723         m_vk.resetQueryPool(device, queryPool, firstQuery, queryCount);
 724 }
 725
 726 VkResult DeviceDriver::getSemaphoreCounterValue (VkDevice device, VkSemaphore semaphore, uint64_t* pValue) const
 727 {
 728         return m_vk.getSemaphoreCounterValue(device, semaphore, pValue);
 729 }
 730
 731 VkResult DeviceDriver::waitSemaphores (VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) const
 732 {
 733         return m_vk.waitSemaphores(device, pWaitInfo, timeout);
 734 }
 735
 736 VkResult DeviceDriver::signalSemaphore (VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) const
 737 {
 738         return m_vk.signalSemaphore(device, pSignalInfo);
 739 }
 740
 741 VkDeviceAddress DeviceDriver::getBufferDeviceAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const
 742 {
 743         return m_vk.getBufferDeviceAddress(device, pInfo);
 744 }
 745
 746 uint64_t DeviceDriver::getBufferOpaqueCaptureAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const
 747 {
 748         return m_vk.getBufferOpaqueCaptureAddress(device, pInfo);
 749 }
 750
 751 uint64_t DeviceDriver::getDeviceMemoryOpaqueCaptureAddress (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) const
 752 {
 753         return m_vk.getDeviceMemoryOpaqueCaptureAddress(device, pInfo);
 754 }
 755
 756 VkResult DeviceDriver::createPrivateDataSlot (VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) const
 757 {
 758         return m_vk.createPrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot);
 759 }
 760
 761 void DeviceDriver::destroyPrivateDataSlot (VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) const
 762 {
 763         m_vk.destroyPrivateDataSlot(device, privateDataSlot, pAllocator);
 764 }
 765
 766 VkResult DeviceDriver::setPrivateData (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const
 767 {
 768         return m_vk.setPrivateData(device, objectType, objectHandle, privateDataSlot, data);
 769 }
 770
 771 void DeviceDriver::getPrivateData (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) const
 772 {
 773         m_vk.getPrivateData(device, objectType, objectHandle, privateDataSlot, pData);
 774 }
 775
 776 void DeviceDriver::cmdSetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) const
 777 {
 778         m_vk.cmdSetEvent2(commandBuffer, event, pDependencyInfo);
 779 }
 780
 781 void DeviceDriver::cmdResetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const
 782 {
 783         m_vk.cmdResetEvent2(commandBuffer, event, stageMask);
 784 }
 785
 786 void DeviceDriver::cmdWaitEvents2 (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) const
 787 {
 788         m_vk.cmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos);
 789 }
 790
 791 void DeviceDriver::cmdPipelineBarrier2 (VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) const
 792 {
 793         m_vk.cmdPipelineBarrier2(commandBuffer, pDependencyInfo);
 794 }
 795
 796 void DeviceDriver::cmdWriteTimestamp2 (VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const
 797 {
 798         m_vk.cmdWriteTimestamp2(commandBuffer, stage, queryPool, query);
 799 }
 800
 801 VkResult DeviceDriver::queueSubmit2 (VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) const
 802 {
 803         return m_vk.queueSubmit2(queue, submitCount, pSubmits, fence);
 804 }
 805
 806 void DeviceDriver::cmdCopyBuffer2 (VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) const
 807 {
 808         m_vk.cmdCopyBuffer2(commandBuffer, pCopyBufferInfo);
 809 }
 810
 811 void DeviceDriver::cmdCopyImage2 (VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) const
 812 {
 813         m_vk.cmdCopyImage2(commandBuffer, pCopyImageInfo);
 814 }
 815
 816 void DeviceDriver::cmdCopyBufferToImage2 (VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) const
 817 {
 818         m_vk.cmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo);
 819 }
 820
 821 void DeviceDriver::cmdCopyImageToBuffer2 (VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) const
 822 {
 823         m_vk.cmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo);
 824 }
 825
 826 void DeviceDriver::cmdBlitImage2 (VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) const
 827 {
 828         m_vk.cmdBlitImage2(commandBuffer, pBlitImageInfo);
 829 }
 830
 831 void DeviceDriver::cmdResolveImage2 (VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) const
 832 {
 833         m_vk.cmdResolveImage2(commandBuffer, pResolveImageInfo);
 834 }
 835
 836 void DeviceDriver::cmdBeginRendering (VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) const
 837 {
 838         m_vk.cmdBeginRendering(commandBuffer, pRenderingInfo);
 839 }
 840
 841 void DeviceDriver::cmdEndRendering (VkCommandBuffer commandBuffer) const
 842 {
 843         m_vk.cmdEndRendering(commandBuffer);
 844 }
 845
 846 void DeviceDriver::cmdSetCullMode (VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const
 847 {
 848         m_vk.cmdSetCullMode(commandBuffer, cullMode);
 849 }
 850
 851 void DeviceDriver::cmdSetFrontFace (VkCommandBuffer commandBuffer, VkFrontFace frontFace) const
 852 {
 853         m_vk.cmdSetFrontFace(commandBuffer, frontFace);
 854 }
 855
 856 void DeviceDriver::cmdSetPrimitiveTopology (VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const
 857 {
 858         m_vk.cmdSetPrimitiveTopology(commandBuffer, primitiveTopology);
 859 }
 860
 861 void DeviceDriver::cmdSetViewportWithCount (VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) const
 862 {
 863         m_vk.cmdSetViewportWithCount(commandBuffer, viewportCount, pViewports);
 864 }
 865
 866 void DeviceDriver::cmdSetScissorWithCount (VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) const
 867 {
 868         m_vk.cmdSetScissorWithCount(commandBuffer, scissorCount, pScissors);
 869 }
 870
 871 void DeviceDriver::cmdBindVertexBuffers2 (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) const
 872 {
 873         m_vk.cmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
 874 }
 875
 876 void DeviceDriver::cmdSetDepthTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const
 877 {
 878         m_vk.cmdSetDepthTestEnable(commandBuffer, depthTestEnable);
 879 }
 880
 881 void DeviceDriver::cmdSetDepthWriteEnable (VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const
 882 {
 883         m_vk.cmdSetDepthWriteEnable(commandBuffer, depthWriteEnable);
 884 }
 885
 886 void DeviceDriver::cmdSetDepthCompareOp (VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const
 887 {
 888         m_vk.cmdSetDepthCompareOp(commandBuffer, depthCompareOp);
 889 }
 890
 891 void DeviceDriver::cmdSetDepthBoundsTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const
 892 {
 893         m_vk.cmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable);
 894 }
 895
 896 void DeviceDriver::cmdSetStencilTestEnable (VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const
 897 {
 898         m_vk.cmdSetStencilTestEnable(commandBuffer, stencilTestEnable);
 899 }
 900
 901 void DeviceDriver::cmdSetStencilOp (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const
 902 {
 903         m_vk.cmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
 904 }
 905
 906 void DeviceDriver::cmdSetRasterizerDiscardEnable (VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const
 907 {
 908         m_vk.cmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable);
 909 }
 910
 911 void DeviceDriver::cmdSetDepthBiasEnable (VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const
 912 {
 913         m_vk.cmdSetDepthBiasEnable(commandBuffer, depthBiasEnable);
 914 }
 915
 916 void DeviceDriver::cmdSetPrimitiveRestartEnable (VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const
 917 {
 918         m_vk.cmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable);
 919 }
 920
 921 void DeviceDriver::getDeviceBufferMemoryRequirements (VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const
 922 {
 923         m_vk.getDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
 924 }
 925
 926 void DeviceDriver::getDeviceImageMemoryRequirements (VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) const
 927 {
 928         m_vk.getDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
 929 }
 930
 931 void DeviceDriver::getDeviceImageSparseMemoryRequirements (VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const
 932 {
 933         m_vk.getDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 934 }
 935
 936 VkResult DeviceDriver::createSwapchainKHR (VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) const
 937 {
 938         return m_vk.createSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
 939 }
 940
 941 void DeviceDriver::destroySwapchainKHR (VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) const
 942 {
 943         m_vk.destroySwapchainKHR(device, swapchain, pAllocator);
 944 }
 945
 946 VkResult DeviceDriver::getSwapchainImagesKHR (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) const
 947 {
 948         return m_vk.getSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
 949 }
 950
 951 VkResult DeviceDriver::acquireNextImageKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) const
 952 {
 953         return m_vk.acquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
 954 }
 955
 956 VkResult DeviceDriver::queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const
 957 {
 958         return m_vk.queuePresentKHR(queue, pPresentInfo);
 959 }
 960
 961 VkResult DeviceDriver::getDeviceGroupPresentCapabilitiesKHR (VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) const
 962 {
 963         return m_vk.getDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
 964 }
 965
 966 VkResult DeviceDriver::getDeviceGroupSurfacePresentModesKHR (VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) const
 967 {
 968         return m_vk.getDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
 969 }
 970
 971 VkResult DeviceDriver::acquireNextImage2KHR (VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) const
 972 {
 973         return m_vk.acquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
 974 }
 975
 976 VkResult DeviceDriver::createSharedSwapchainsKHR (VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const
 977 {
 978         return m_vk.createSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
 979 }
 980
 981 VkResult DeviceDriver::getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const
 982 {
 983         return m_vk.getMemoryFdKHR(device, pGetFdInfo, pFd);
 984 }
 985
 986 VkResult DeviceDriver::getMemoryFdPropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) const
 987 {
 988         return m_vk.getMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
 989 }
 990
 991 VkResult DeviceDriver::importSemaphoreFdKHR (VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) const
 992 {
 993         return m_vk.importSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
 994 }
 995
 996 VkResult DeviceDriver::getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) const
 997 {
 998         return m_vk.getSemaphoreFdKHR(device, pGetFdInfo, pFd);
 999 }
1000
1001 void DeviceDriver::cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const
1002 {
1003         m_vk.cmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
1004 }
1005
1006 void DeviceDriver::cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) const
1007 {
1008         m_vk.cmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
1009 }
1010
1011 VkResult DeviceDriver::getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const
1012 {
1013         return m_vk.getSwapchainStatusKHR(device, swapchain);
1014 }
1015
1016 VkResult DeviceDriver::importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const
1017 {
1018         return m_vk.importFenceFdKHR(device, pImportFenceFdInfo);
1019 }
1020
1021 VkResult DeviceDriver::getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const
1022 {
1023         return m_vk.getFenceFdKHR(device, pGetFdInfo, pFd);
1024 }
1025
1026 VkResult DeviceDriver::acquireProfilingLockKHR (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) const
1027 {
1028         return m_vk.acquireProfilingLockKHR(device, pInfo);
1029 }
1030
1031 void DeviceDriver::releaseProfilingLockKHR (VkDevice device) const
1032 {
1033         m_vk.releaseProfilingLockKHR(device);
1034 }
1035
1036 void DeviceDriver::cmdSetFragmentShadingRateKHR (VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const
1037 {
1038         m_vk.cmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps);
1039 }
1040
1041 VkResult DeviceDriver::waitForPresentKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) const
1042 {
1043         return m_vk.waitForPresentKHR(device, swapchain, presentId, timeout);
1044 }
1045
1046 VkResult DeviceDriver::createDeferredOperationKHR (VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) const
1047 {
1048         return m_vk.createDeferredOperationKHR(device, pAllocator, pDeferredOperation);
1049 }
1050
1051 void DeviceDriver::destroyDeferredOperationKHR (VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) const
1052 {
1053         m_vk.destroyDeferredOperationKHR(device, operation, pAllocator);
1054 }
1055
1056 uint32_t DeviceDriver::getDeferredOperationMaxConcurrencyKHR (VkDevice device, VkDeferredOperationKHR operation) const
1057 {
1058         return m_vk.getDeferredOperationMaxConcurrencyKHR(device, operation);
1059 }
1060
1061 VkResult DeviceDriver::getDeferredOperationResultKHR (VkDevice device, VkDeferredOperationKHR operation) const
1062 {
1063         return m_vk.getDeferredOperationResultKHR(device, operation);
1064 }
1065
1066 VkResult DeviceDriver::deferredOperationJoinKHR (VkDevice device, VkDeferredOperationKHR operation) const
1067 {
1068         return m_vk.deferredOperationJoinKHR(device, operation);
1069 }
1070
1071 VkResult DeviceDriver::getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const
1072 {
1073         return m_vk.getPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
1074 }
1075
1076 VkResult DeviceDriver::getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) const
1077 {
1078         return m_vk.getPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
1079 }
1080
1081 VkResult DeviceDriver::getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const
1082 {
1083         return m_vk.getPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
1084 }
1085
1086 void DeviceDriver::cmdWriteBufferMarker2AMD (VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const
1087 {
1088         m_vk.cmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
1089 }
1090
1091 void DeviceDriver::getQueueCheckpointData2NV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) const
1092 {
1093         m_vk.getQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData);
1094 }
1095
1096 void DeviceDriver::cmdTraceRaysIndirect2KHR (VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) const
1097 {
1098         m_vk.cmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress);
1099 }
1100
1101 VkResult DeviceDriver::debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const
1102 {
1103         return m_vk.debugMarkerSetObjectTagEXT(device, pTagInfo);
1104 }
1105
1106 VkResult DeviceDriver::debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const
1107 {
1108         return m_vk.debugMarkerSetObjectNameEXT(device, pNameInfo);
1109 }
1110
1111 void DeviceDriver::cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const
1112 {
1113         m_vk.cmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
1114 }
1115
1116 void DeviceDriver::cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer) const
1117 {
1118         m_vk.cmdDebugMarkerEndEXT(commandBuffer);
1119 }
1120
1121 void DeviceDriver::cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const
1122 {
1123         m_vk.cmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
1124 }
1125
1126 void DeviceDriver::cmdBindTransformFeedbackBuffersEXT (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) const
1127 {
1128         m_vk.cmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
1129 }
1130
1131 void DeviceDriver::cmdBeginTransformFeedbackEXT (VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) const
1132 {
1133         m_vk.cmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
1134 }
1135
1136 void DeviceDriver::cmdEndTransformFeedbackEXT (VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) const
1137 {
1138         m_vk.cmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
1139 }
1140
1141 void DeviceDriver::cmdBeginQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) const
1142 {
1143         m_vk.cmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
1144 }
1145
1146 void DeviceDriver::cmdEndQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) const
1147 {
1148         m_vk.cmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
1149 }
1150
1151 void DeviceDriver::cmdDrawIndirectByteCountEXT (VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) const
1152 {
1153         m_vk.cmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
1154 }
1155
1156 VkResult DeviceDriver::createCuModuleNVX (VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) const
1157 {
1158         return m_vk.createCuModuleNVX(device, pCreateInfo, pAllocator, pModule);
1159 }
1160
1161 VkResult DeviceDriver::createCuFunctionNVX (VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) const
1162 {
1163         return m_vk.createCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction);
1164 }
1165
1166 void DeviceDriver::destroyCuModuleNVX (VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) const
1167 {
1168         m_vk.destroyCuModuleNVX(device, module, pAllocator);
1169 }
1170
1171 void DeviceDriver::destroyCuFunctionNVX (VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) const
1172 {
1173         m_vk.destroyCuFunctionNVX(device, function, pAllocator);
1174 }
1175
1176 void DeviceDriver::cmdCuLaunchKernelNVX (VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) const
1177 {
1178         m_vk.cmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo);
1179 }
1180
1181 uint32_t DeviceDriver::getImageViewHandleNVX (VkDevice device, const VkImageViewHandleInfoNVX* pInfo) const
1182 {
1183         return m_vk.getImageViewHandleNVX(device, pInfo);
1184 }
1185
1186 VkResult DeviceDriver::getImageViewAddressNVX (VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) const
1187 {
1188         return m_vk.getImageViewAddressNVX(device, imageView, pProperties);
1189 }
1190
1191 void DeviceDriver::cmdDrawIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
1192 {
1193         m_vk.cmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1194 }
1195
1196 void DeviceDriver::cmdDrawIndexedIndirectCountAMD (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
1197 {
1198         m_vk.cmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1199 }
1200
1201 VkResult DeviceDriver::getShaderInfoAMD (VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) const
1202 {
1203         return m_vk.getShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
1204 }
1205
1206 void DeviceDriver::cmdBeginConditionalRenderingEXT (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) const
1207 {
1208         m_vk.cmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
1209 }
1210
1211 void DeviceDriver::cmdEndConditionalRenderingEXT (VkCommandBuffer commandBuffer) const
1212 {
1213         m_vk.cmdEndConditionalRenderingEXT(commandBuffer);
1214 }
1215
1216 void DeviceDriver::cmdSetViewportWScalingNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) const
1217 {
1218         m_vk.cmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
1219 }
1220
1221 VkResult DeviceDriver::displayPowerControlEXT (VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) const
1222 {
1223         return m_vk.displayPowerControlEXT(device, display, pDisplayPowerInfo);
1224 }
1225
1226 VkResult DeviceDriver::registerDeviceEventEXT (VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const
1227 {
1228         return m_vk.registerDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
1229 }
1230
1231 VkResult DeviceDriver::registerDisplayEventEXT (VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const
1232 {
1233         return m_vk.registerDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
1234 }
1235
1236 VkResult DeviceDriver::getSwapchainCounterEXT (VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) const
1237 {
1238         return m_vk.getSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
1239 }
1240
1241 VkResult DeviceDriver::getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const
1242 {
1243         return m_vk.getRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
1244 }
1245
1246 VkResult DeviceDriver::getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) const
1247 {
1248         return m_vk.getPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
1249 }
1250
1251 void DeviceDriver::cmdSetDiscardRectangleEXT (VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) const
1252 {
1253         m_vk.cmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
1254 }
1255
1256 void DeviceDriver::setHdrMetadataEXT (VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) const
1257 {
1258         m_vk.setHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
1259 }
1260
1261 VkResult DeviceDriver::setDebugUtilsObjectNameEXT (VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) const
1262 {
1263         return m_vk.setDebugUtilsObjectNameEXT(device, pNameInfo);
1264 }
1265
1266 VkResult DeviceDriver::setDebugUtilsObjectTagEXT (VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) const
1267 {
1268         return m_vk.setDebugUtilsObjectTagEXT(device, pTagInfo);
1269 }
1270
1271 void DeviceDriver::queueBeginDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const
1272 {
1273         m_vk.queueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
1274 }
1275
1276 void DeviceDriver::queueEndDebugUtilsLabelEXT (VkQueue queue) const
1277 {
1278         m_vk.queueEndDebugUtilsLabelEXT(queue);
1279 }
1280
1281 void DeviceDriver::queueInsertDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const
1282 {
1283         m_vk.queueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
1284 }
1285
1286 void DeviceDriver::cmdBeginDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const
1287 {
1288         m_vk.cmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
1289 }
1290
1291 void DeviceDriver::cmdEndDebugUtilsLabelEXT (VkCommandBuffer commandBuffer) const
1292 {
1293         m_vk.cmdEndDebugUtilsLabelEXT(commandBuffer);
1294 }
1295
1296 void DeviceDriver::cmdInsertDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const
1297 {
1298         m_vk.cmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
1299 }
1300
1301 void DeviceDriver::cmdSetSampleLocationsEXT (VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) const
1302 {
1303         m_vk.cmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
1304 }
1305
1306 VkResult DeviceDriver::getImageDrmFormatModifierPropertiesEXT (VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) const
1307 {
1308         return m_vk.getImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
1309 }
1310
1311 VkResult DeviceDriver::createValidationCacheEXT (VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) const
1312 {
1313         return m_vk.createValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
1314 }
1315
1316 void DeviceDriver::destroyValidationCacheEXT (VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) const
1317 {
1318         m_vk.destroyValidationCacheEXT(device, validationCache, pAllocator);
1319 }
1320
1321 VkResult DeviceDriver::mergeValidationCachesEXT (VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) const
1322 {
1323         return m_vk.mergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
1324 }
1325
1326 VkResult DeviceDriver::getValidationCacheDataEXT (VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) const
1327 {
1328         return m_vk.getValidationCacheDataEXT(device, validationCache, pDataSize, pData);
1329 }
1330
1331 void DeviceDriver::cmdBindShadingRateImageNV (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const
1332 {
1333         m_vk.cmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
1334 }
1335
1336 void DeviceDriver::cmdSetViewportShadingRatePaletteNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) const
1337 {
1338         m_vk.cmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
1339 }
1340
1341 void DeviceDriver::cmdSetCoarseSampleOrderNV (VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) const
1342 {
1343         m_vk.cmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
1344 }
1345
1346 VkResult DeviceDriver::createAccelerationStructureNV (VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) const
1347 {
1348         return m_vk.createAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
1349 }
1350
1351 void DeviceDriver::destroyAccelerationStructureNV (VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) const
1352 {
1353         m_vk.destroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
1354 }
1355
1356 void DeviceDriver::getAccelerationStructureMemoryRequirementsNV (VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const
1357 {
1358         m_vk.getAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
1359 }
1360
1361 VkResult DeviceDriver::bindAccelerationStructureMemoryNV (VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) const
1362 {
1363         return m_vk.bindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos);
1364 }
1365
1366 void DeviceDriver::cmdBuildAccelerationStructureNV (VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) const
1367 {
1368         m_vk.cmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
1369 }
1370
1371 void DeviceDriver::cmdCopyAccelerationStructureNV (VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) const
1372 {
1373         m_vk.cmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
1374 }
1375
1376 void DeviceDriver::cmdTraceRaysNV (VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) const
1377 {
1378         m_vk.cmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
1379 }
1380
1381 VkResult DeviceDriver::createRayTracingPipelinesNV (VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const
1382 {
1383         return m_vk.createRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
1384 }
1385
1386 VkResult DeviceDriver::getRayTracingShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const
1387 {
1388         return m_vk.getRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
1389 }
1390
1391 VkResult DeviceDriver::getRayTracingShaderGroupHandlesNV (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const
1392 {
1393         return m_vk.getRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
1394 }
1395
1396 VkResult DeviceDriver::getAccelerationStructureHandleNV (VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) const
1397 {
1398         return m_vk.getAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
1399 }
1400
1401 void DeviceDriver::cmdWriteAccelerationStructuresPropertiesNV (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const
1402 {
1403         m_vk.cmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
1404 }
1405
1406 VkResult DeviceDriver::compileDeferredNV (VkDevice device, VkPipeline pipeline, uint32_t shader) const
1407 {
1408         return m_vk.compileDeferredNV(device, pipeline, shader);
1409 }
1410
1411 VkResult DeviceDriver::getMemoryHostPointerPropertiesEXT (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) const
1412 {
1413         return m_vk.getMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
1414 }
1415
1416 void DeviceDriver::cmdWriteBufferMarkerAMD (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const
1417 {
1418         m_vk.cmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
1419 }
1420
1421 VkResult DeviceDriver::getCalibratedTimestampsEXT (VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) const
1422 {
1423         return m_vk.getCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
1424 }
1425
1426 void DeviceDriver::cmdDrawMeshTasksNV (VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const
1427 {
1428         m_vk.cmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
1429 }
1430
1431 void DeviceDriver::cmdDrawMeshTasksIndirectNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
1432 {
1433         m_vk.cmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
1434 }
1435
1436 void DeviceDriver::cmdDrawMeshTasksIndirectCountNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
1437 {
1438         m_vk.cmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1439 }
1440
1441 void DeviceDriver::cmdSetExclusiveScissorNV (VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) const
1442 {
1443         m_vk.cmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
1444 }
1445
1446 void DeviceDriver::cmdSetCheckpointNV (VkCommandBuffer commandBuffer, const void* pCheckpointMarker) const
1447 {
1448         m_vk.cmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
1449 }
1450
1451 void DeviceDriver::getQueueCheckpointDataNV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) const
1452 {
1453         m_vk.getQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
1454 }
1455
1456 VkResult DeviceDriver::initializePerformanceApiINTEL (VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) const
1457 {
1458         return m_vk.initializePerformanceApiINTEL(device, pInitializeInfo);
1459 }
1460
1461 void DeviceDriver::uninitializePerformanceApiINTEL (VkDevice device) const
1462 {
1463         m_vk.uninitializePerformanceApiINTEL(device);
1464 }
1465
1466 VkResult DeviceDriver::cmdSetPerformanceMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) const
1467 {
1468         return m_vk.cmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo);
1469 }
1470
1471 VkResult DeviceDriver::cmdSetPerformanceStreamMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) const
1472 {
1473         return m_vk.cmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo);
1474 }
1475
1476 VkResult DeviceDriver::cmdSetPerformanceOverrideINTEL (VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) const
1477 {
1478         return m_vk.cmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo);
1479 }
1480
1481 VkResult DeviceDriver::acquirePerformanceConfigurationINTEL (VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) const
1482 {
1483         return m_vk.acquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
1484 }
1485
1486 VkResult DeviceDriver::releasePerformanceConfigurationINTEL (VkDevice device, VkPerformanceConfigurationINTEL configuration) const
1487 {
1488         return m_vk.releasePerformanceConfigurationINTEL(device, configuration);
1489 }
1490
1491 VkResult DeviceDriver::queueSetPerformanceConfigurationINTEL (VkQueue queue, VkPerformanceConfigurationINTEL configuration) const
1492 {
1493         return m_vk.queueSetPerformanceConfigurationINTEL(queue, configuration);
1494 }
1495
1496 VkResult DeviceDriver::getPerformanceParameterINTEL (VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) const
1497 {
1498         return m_vk.getPerformanceParameterINTEL(device, parameter, pValue);
1499 }
1500
1501 void DeviceDriver::setLocalDimmingAMD (VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const
1502 {
1503         m_vk.setLocalDimmingAMD(device, swapChain, localDimmingEnable);
1504 }
1505
1506 VkDeviceAddress DeviceDriver::getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const
1507 {
1508         return m_vk.getBufferDeviceAddressEXT(device, pInfo);
1509 }
1510
1511 void DeviceDriver::cmdSetLineStippleEXT (VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const
1512 {
1513         m_vk.cmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
1514 }
1515
1516 void DeviceDriver::getGeneratedCommandsMemoryRequirementsNV (VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) const
1517 {
1518         m_vk.getGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
1519 }
1520
1521 void DeviceDriver::cmdPreprocessGeneratedCommandsNV (VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const
1522 {
1523         m_vk.cmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo);
1524 }
1525
1526 void DeviceDriver::cmdExecuteGeneratedCommandsNV (VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const
1527 {
1528         m_vk.cmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
1529 }
1530
1531 void DeviceDriver::cmdBindPipelineShaderGroupNV (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) const
1532 {
1533         m_vk.cmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
1534 }
1535
1536 VkResult DeviceDriver::createIndirectCommandsLayoutNV (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) const
1537 {
1538         return m_vk.createIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
1539 }
1540
1541 void DeviceDriver::destroyIndirectCommandsLayoutNV (VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) const
1542 {
1543         m_vk.destroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator);
1544 }
1545
1546 void DeviceDriver::cmdSetFragmentShadingRateEnumNV (VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const
1547 {
1548         m_vk.cmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps);
1549 }
1550
1551 void DeviceDriver::getImageSubresourceLayout2EXT (VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) const
1552 {
1553         m_vk.getImageSubresourceLayout2EXT(device, image, pSubresource, pLayout);
1554 }
1555
1556 void DeviceDriver::cmdSetVertexInputEXT (VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) const
1557 {
1558         m_vk.cmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
1559 }
1560
1561 VkResult DeviceDriver::getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI (VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) const
1562 {
1563         return m_vk.getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize);
1564 }
1565
1566 void DeviceDriver::cmdSubpassShadingHUAWEI (VkCommandBuffer commandBuffer) const
1567 {
1568         m_vk.cmdSubpassShadingHUAWEI(commandBuffer);
1569 }
1570
1571 void DeviceDriver::cmdBindInvocationMaskHUAWEI (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const
1572 {
1573         m_vk.cmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout);
1574 }
1575
1576 VkResult DeviceDriver::getMemoryRemoteAddressNV (VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) const
1577 {
1578         return m_vk.getMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress);
1579 }
1580
1581 VkResult DeviceDriver::getPipelinePropertiesEXT (VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) const
1582 {
1583         return m_vk.getPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties);
1584 }
1585
1586 void DeviceDriver::cmdSetPatchControlPointsEXT (VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const
1587 {
1588         m_vk.cmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints);
1589 }
1590
1591 void DeviceDriver::cmdSetLogicOpEXT (VkCommandBuffer commandBuffer, VkLogicOp logicOp) const
1592 {
1593         m_vk.cmdSetLogicOpEXT(commandBuffer, logicOp);
1594 }
1595
1596 void DeviceDriver::cmdSetColorWriteEnableEXT (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) const
1597 {
1598         m_vk.cmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables);
1599 }
1600
1601 void DeviceDriver::cmdDrawMultiEXT (VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) const
1602 {
1603         m_vk.cmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
1604 }
1605
1606 void DeviceDriver::cmdDrawMultiIndexedEXT (VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) const
1607 {
1608         m_vk.cmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
1609 }
1610
1611 void DeviceDriver::setDeviceMemoryPriorityEXT (VkDevice device, VkDeviceMemory memory, float priority) const
1612 {
1613         m_vk.setDeviceMemoryPriorityEXT(device, memory, priority);
1614 }
1615
1616 void DeviceDriver::getDescriptorSetLayoutHostMappingInfoVALVE (VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) const
1617 {
1618         m_vk.getDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping);
1619 }
1620
1621 void DeviceDriver::getDescriptorSetHostMappingVALVE (VkDevice device, VkDescriptorSet descriptorSet, void** ppData) const
1622 {
1623         m_vk.getDescriptorSetHostMappingVALVE(device, descriptorSet, ppData);
1624 }
1625
1626 void DeviceDriver::getShaderModuleIdentifierEXT (VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) const
1627 {
1628         m_vk.getShaderModuleIdentifierEXT(device, shaderModule, pIdentifier);
1629 }
1630
1631 void DeviceDriver::getShaderModuleCreateInfoIdentifierEXT (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) const
1632 {
1633         m_vk.getShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier);
1634 }
1635
1636 VkResult DeviceDriver::createAccelerationStructureKHR (VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const
1637 {
1638         return m_vk.createAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure);
1639 }
1640
1641 void DeviceDriver::destroyAccelerationStructureKHR (VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) const
1642 {
1643         m_vk.destroyAccelerationStructureKHR(device, accelerationStructure, pAllocator);
1644 }
1645
1646 void DeviceDriver::cmdBuildAccelerationStructuresKHR (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const
1647 {
1648         m_vk.cmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
1649 }
1650
1651 void DeviceDriver::cmdBuildAccelerationStructuresIndirectKHR (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) const
1652 {
1653         m_vk.cmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
1654 }
1655
1656 VkResult DeviceDriver::buildAccelerationStructuresKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const
1657 {
1658         return m_vk.buildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
1659 }
1660
1661 VkResult DeviceDriver::copyAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) const
1662 {
1663         return m_vk.copyAccelerationStructureKHR(device, deferredOperation, pInfo);
1664 }
1665
1666 VkResult DeviceDriver::copyAccelerationStructureToMemoryKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const
1667 {
1668         return m_vk.copyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo);
1669 }
1670
1671 VkResult DeviceDriver::copyMemoryToAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const
1672 {
1673         return m_vk.copyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo);
1674 }
1675
1676 VkResult DeviceDriver::writeAccelerationStructuresPropertiesKHR (VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) const
1677 {
1678         return m_vk.writeAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
1679 }
1680
1681 void DeviceDriver::cmdCopyAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) const
1682 {
1683         m_vk.cmdCopyAccelerationStructureKHR(commandBuffer, pInfo);
1684 }
1685
1686 void DeviceDriver::cmdCopyAccelerationStructureToMemoryKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const
1687 {
1688         m_vk.cmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo);
1689 }
1690
1691 void DeviceDriver::cmdCopyMemoryToAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const
1692 {
1693         m_vk.cmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo);
1694 }
1695
1696 VkDeviceAddress DeviceDriver::getAccelerationStructureDeviceAddressKHR (VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) const
1697 {
1698         return m_vk.getAccelerationStructureDeviceAddressKHR(device, pInfo);
1699 }
1700
1701 void DeviceDriver::cmdWriteAccelerationStructuresPropertiesKHR (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const
1702 {
1703         m_vk.cmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
1704 }
1705
1706 void DeviceDriver::getDeviceAccelerationStructureCompatibilityKHR (VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) const
1707 {
1708         m_vk.getDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility);
1709 }
1710
1711 void DeviceDriver::getAccelerationStructureBuildSizesKHR (VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) const
1712 {
1713         m_vk.getAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
1714 }
1715
1716 void DeviceDriver::cmdTraceRaysKHR (VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) const
1717 {
1718         m_vk.cmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
1719 }
1720
1721 VkResult DeviceDriver::createRayTracingPipelinesKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const
1722 {
1723         return m_vk.createRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
1724 }
1725
1726 VkResult DeviceDriver::getRayTracingCaptureReplayShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const
1727 {
1728         return m_vk.getRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
1729 }
1730
1731 void DeviceDriver::cmdTraceRaysIndirectKHR (VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) const
1732 {
1733         m_vk.cmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
1734 }
1735
1736 VkDeviceSize DeviceDriver::getRayTracingShaderGroupStackSizeKHR (VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) const
1737 {
1738         return m_vk.getRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
1739 }
1740
1741 void DeviceDriver::cmdSetRayTracingPipelineStackSizeKHR (VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) const
1742 {
1743         m_vk.cmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize);
1744 }
1745
1746 VkResult DeviceDriver::getAndroidHardwareBufferPropertiesANDROID (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) const
1747 {
1748         return m_vk.getAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
1749 }
1750
1751 VkResult DeviceDriver::getMemoryAndroidHardwareBufferANDROID (VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct pt::AndroidHardwareBufferPtr* pBuffer) const
1752 {
1753         return m_vk.getMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
1754 }
1755
1756 VkResult DeviceDriver::createVideoSessionKHR (VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) const
1757 {
1758         return m_vk.createVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession);
1759 }
1760
1761 void DeviceDriver::destroyVideoSessionKHR (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) const
1762 {
1763         m_vk.destroyVideoSessionKHR(device, videoSession, pAllocator);
1764 }
1765
1766 VkResult DeviceDriver::getVideoSessionMemoryRequirementsKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) const
1767 {
1768         return m_vk.getVideoSessionMemoryRequirementsKHR(device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements);
1769 }
1770
1771 VkResult DeviceDriver::bindVideoSessionMemoryKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories) const
1772 {
1773         return m_vk.bindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories);
1774 }
1775
1776 VkResult DeviceDriver::createVideoSessionParametersKHR (VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) const
1777 {
1778         return m_vk.createVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters);
1779 }
1780
1781 VkResult DeviceDriver::updateVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) const
1782 {
1783         return m_vk.updateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo);
1784 }
1785
1786 void DeviceDriver::destroyVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) const
1787 {
1788         m_vk.destroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator);
1789 }
1790
1791 void DeviceDriver::cmdBeginVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) const
1792 {
1793         m_vk.cmdBeginVideoCodingKHR(commandBuffer, pBeginInfo);
1794 }
1795
1796 void DeviceDriver::cmdEndVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) const
1797 {
1798         m_vk.cmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo);
1799 }
1800
1801 void DeviceDriver::cmdControlVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) const
1802 {
1803         m_vk.cmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo);
1804 }
1805
1806 void DeviceDriver::cmdDecodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo) const
1807 {
1808         m_vk.cmdDecodeVideoKHR(commandBuffer, pFrameInfo);
1809 }
1810
1811 void DeviceDriver::cmdEncodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) const
1812 {
1813         m_vk.cmdEncodeVideoKHR(commandBuffer, pEncodeInfo);
1814 }
1815
1816 VkResult DeviceDriver::getMemoryZirconHandleFUCHSIA (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle) const
1817 {
1818         return m_vk.getMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
1819 }
1820
1821 VkResult DeviceDriver::getMemoryZirconHandlePropertiesFUCHSIA (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const
1822 {
1823         return m_vk.getMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties);
1824 }
1825
1826 VkResult DeviceDriver::importSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const
1827 {
1828         return m_vk.importSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
1829 }
1830
1831 VkResult DeviceDriver::getSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle) const
1832 {
1833         return m_vk.getSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
1834 }
1835
1836 VkResult DeviceDriver::createBufferCollectionFUCHSIA (VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) const
1837 {
1838         return m_vk.createBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection);
1839 }
1840
1841 VkResult DeviceDriver::setBufferCollectionImageConstraintsFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) const
1842 {
1843         return m_vk.setBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo);
1844 }
1845
1846 VkResult DeviceDriver::setBufferCollectionBufferConstraintsFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) const
1847 {
1848         return m_vk.setBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
1849 }
1850
1851 void DeviceDriver::destroyBufferCollectionFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) const
1852 {
1853         m_vk.destroyBufferCollectionFUCHSIA(device, collection, pAllocator);
1854 }
1855
1856 VkResult DeviceDriver::getBufferCollectionPropertiesFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) const
1857 {
1858         return m_vk.getBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
1859 }
1860
1861 VkResult DeviceDriver::getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const
1862 {
1863         return m_vk.getMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
1864 }
1865
1866 VkResult DeviceDriver::getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) const
1867 {
1868         return m_vk.getMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
1869 }
1870
1871 VkResult DeviceDriver::importSemaphoreWin32HandleKHR (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) const
1872 {
1873         return m_vk.importSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
1874 }
1875
1876 VkResult DeviceDriver::getSemaphoreWin32HandleKHR (VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const
1877 {
1878         return m_vk.getSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
1879 }
1880
1881 VkResult DeviceDriver::importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) const
1882 {
1883         return m_vk.importFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
1884 }
1885
1886 VkResult DeviceDriver::getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const
1887 {
1888         return m_vk.getFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
1889 }
1890
1891 VkResult DeviceDriver::getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle) const
1892 {
1893         return m_vk.getMemoryWin32HandleNV(device, memory, handleType, pHandle);
1894 }
1895
1896 VkResult DeviceDriver::acquireFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain) const
1897 {
1898         return m_vk.acquireFullScreenExclusiveModeEXT(device, swapchain);
1899 }
1900
1901 VkResult DeviceDriver::releaseFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain) const
1902 {
1903         return m_vk.releaseFullScreenExclusiveModeEXT(device, swapchain);
1904 }
1905
1906 VkResult DeviceDriver::getDeviceGroupSurfacePresentModes2EXT (VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) const
1907 {
1908         return m_vk.getDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes);
1909 }