external/vulkancts/framework/vulkan/generated/vulkan/vkDeviceDriverImpl.inl

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