external/vulkancts/framework/vulkan/vkDeviceDriverImpl.inl

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