dlls/winevulkan/loader_thunks.c

   1 /* Automatically generated from Vulkan vk.xml; DO NOT EDIT!
   2  *
   3  * This file is generated from Vulkan vk.xml file covered
   4  * by the following copyright and permission notice:
   5  *
   6  * Copyright 2015-2023 The Khronos Group Inc.
   7  *
   8  * SPDX-License-Identifier: Apache-2.0 OR MIT
   9  *
  10  */
  11
  12 #include "vulkan_loader.h"
  13
  14 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  15
  16 VkResult WINAPI vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
  17 {
  18     struct vkAcquireNextImage2KHR_params params;
  19     NTSTATUS status;
  20     params.device = device;
  21     params.pAcquireInfo = pAcquireInfo;
  22     params.pImageIndex = pImageIndex;
  23     status = UNIX_CALL(vkAcquireNextImage2KHR, &params);
  24     assert(!status && "vkAcquireNextImage2KHR");
  25     return params.result;
  26 }
  27
  28 VkResult WINAPI vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
  29 {
  30     struct vkAcquireNextImageKHR_params params;
  31     NTSTATUS status;
  32     params.device = device;
  33     params.swapchain = swapchain;
  34     params.timeout = timeout;
  35     params.semaphore = semaphore;
  36     params.fence = fence;
  37     params.pImageIndex = pImageIndex;
  38     status = UNIX_CALL(vkAcquireNextImageKHR, &params);
  39     assert(!status && "vkAcquireNextImageKHR");
  40     return params.result;
  41 }
  42
  43 VkResult WINAPI vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
  44 {
  45     struct vkAcquirePerformanceConfigurationINTEL_params params;
  46     NTSTATUS status;
  47     params.device = device;
  48     params.pAcquireInfo = pAcquireInfo;
  49     params.pConfiguration = pConfiguration;
  50     status = UNIX_CALL(vkAcquirePerformanceConfigurationINTEL, &params);
  51     assert(!status && "vkAcquirePerformanceConfigurationINTEL");
  52     return params.result;
  53 }
  54
  55 VkResult WINAPI vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
  56 {
  57     struct vkAcquireProfilingLockKHR_params params;
  58     NTSTATUS status;
  59     params.device = device;
  60     params.pInfo = pInfo;
  61     status = UNIX_CALL(vkAcquireProfilingLockKHR, &params);
  62     assert(!status && "vkAcquireProfilingLockKHR");
  63     return params.result;
  64 }
  65
  66 VkResult WINAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
  67 {
  68     struct vkAllocateDescriptorSets_params params;
  69     NTSTATUS status;
  70     params.device = device;
  71     params.pAllocateInfo = pAllocateInfo;
  72     params.pDescriptorSets = pDescriptorSets;
  73     status = UNIX_CALL(vkAllocateDescriptorSets, &params);
  74     assert(!status && "vkAllocateDescriptorSets");
  75     return params.result;
  76 }
  77
  78 VkResult WINAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
  79 {
  80     struct vkAllocateMemory_params params;
  81     NTSTATUS status;
  82     params.device = device;
  83     params.pAllocateInfo = pAllocateInfo;
  84     params.pAllocator = pAllocator;
  85     params.pMemory = pMemory;
  86     status = UNIX_CALL(vkAllocateMemory, &params);
  87     assert(!status && "vkAllocateMemory");
  88     return params.result;
  89 }
  90
  91 VkResult WINAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
  92 {
  93     struct vkBeginCommandBuffer_params params;
  94     NTSTATUS status;
  95     params.commandBuffer = commandBuffer;
  96     params.pBeginInfo = pBeginInfo;
  97     status = UNIX_CALL(vkBeginCommandBuffer, &params);
  98     assert(!status && "vkBeginCommandBuffer");
  99     return params.result;
 100 }
 101
 102 VkResult WINAPI vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
 103 {
 104     struct vkBindAccelerationStructureMemoryNV_params params;
 105     NTSTATUS status;
 106     params.device = device;
 107     params.bindInfoCount = bindInfoCount;
 108     params.pBindInfos = pBindInfos;
 109     status = UNIX_CALL(vkBindAccelerationStructureMemoryNV, &params);
 110     assert(!status && "vkBindAccelerationStructureMemoryNV");
 111     return params.result;
 112 }
 113
 114 VkResult WINAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 115 {
 116     struct vkBindBufferMemory_params params;
 117     NTSTATUS status;
 118     params.device = device;
 119     params.buffer = buffer;
 120     params.memory = memory;
 121     params.memoryOffset = memoryOffset;
 122     status = UNIX_CALL(vkBindBufferMemory, &params);
 123     assert(!status && "vkBindBufferMemory");
 124     return params.result;
 125 }
 126
 127 VkResult WINAPI vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
 128 {
 129     struct vkBindBufferMemory2_params params;
 130     NTSTATUS status;
 131     params.device = device;
 132     params.bindInfoCount = bindInfoCount;
 133     params.pBindInfos = pBindInfos;
 134     status = UNIX_CALL(vkBindBufferMemory2, &params);
 135     assert(!status && "vkBindBufferMemory2");
 136     return params.result;
 137 }
 138
 139 VkResult WINAPI vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
 140 {
 141     struct vkBindBufferMemory2KHR_params params;
 142     NTSTATUS status;
 143     params.device = device;
 144     params.bindInfoCount = bindInfoCount;
 145     params.pBindInfos = pBindInfos;
 146     status = UNIX_CALL(vkBindBufferMemory2KHR, &params);
 147     assert(!status && "vkBindBufferMemory2KHR");
 148     return params.result;
 149 }
 150
 151 VkResult WINAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 152 {
 153     struct vkBindImageMemory_params params;
 154     NTSTATUS status;
 155     params.device = device;
 156     params.image = image;
 157     params.memory = memory;
 158     params.memoryOffset = memoryOffset;
 159     status = UNIX_CALL(vkBindImageMemory, &params);
 160     assert(!status && "vkBindImageMemory");
 161     return params.result;
 162 }
 163
 164 VkResult WINAPI vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
 165 {
 166     struct vkBindImageMemory2_params params;
 167     NTSTATUS status;
 168     params.device = device;
 169     params.bindInfoCount = bindInfoCount;
 170     params.pBindInfos = pBindInfos;
 171     status = UNIX_CALL(vkBindImageMemory2, &params);
 172     assert(!status && "vkBindImageMemory2");
 173     return params.result;
 174 }
 175
 176 VkResult WINAPI vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
 177 {
 178     struct vkBindImageMemory2KHR_params params;
 179     NTSTATUS status;
 180     params.device = device;
 181     params.bindInfoCount = bindInfoCount;
 182     params.pBindInfos = pBindInfos;
 183     status = UNIX_CALL(vkBindImageMemory2KHR, &params);
 184     assert(!status && "vkBindImageMemory2KHR");
 185     return params.result;
 186 }
 187
 188 VkResult WINAPI vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
 189 {
 190     struct vkBindOpticalFlowSessionImageNV_params params;
 191     NTSTATUS status;
 192     params.device = device;
 193     params.session = session;
 194     params.bindingPoint = bindingPoint;
 195     params.view = view;
 196     params.layout = layout;
 197     status = UNIX_CALL(vkBindOpticalFlowSessionImageNV, &params);
 198     assert(!status && "vkBindOpticalFlowSessionImageNV");
 199     return params.result;
 200 }
 201
 202 VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 203 {
 204     struct vkBuildAccelerationStructuresKHR_params params;
 205     NTSTATUS status;
 206     params.device = device;
 207     params.deferredOperation = deferredOperation;
 208     params.infoCount = infoCount;
 209     params.pInfos = pInfos;
 210     params.ppBuildRangeInfos = ppBuildRangeInfos;
 211     status = UNIX_CALL(vkBuildAccelerationStructuresKHR, &params);
 212     assert(!status && "vkBuildAccelerationStructuresKHR");
 213     return params.result;
 214 }
 215
 216 VkResult WINAPI vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
 217 {
 218     struct vkBuildMicromapsEXT_params params;
 219     NTSTATUS status;
 220     params.device = device;
 221     params.deferredOperation = deferredOperation;
 222     params.infoCount = infoCount;
 223     params.pInfos = pInfos;
 224     status = UNIX_CALL(vkBuildMicromapsEXT, &params);
 225     assert(!status && "vkBuildMicromapsEXT");
 226     return params.result;
 227 }
 228
 229 void WINAPI vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
 230 {
 231     struct vkCmdBeginConditionalRenderingEXT_params params;
 232     params.commandBuffer = commandBuffer;
 233     params.pConditionalRenderingBegin = pConditionalRenderingBegin;
 234     UNIX_CALL(vkCmdBeginConditionalRenderingEXT, &params);
 235 }
 236
 237 void WINAPI vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
 238 {
 239     struct vkCmdBeginDebugUtilsLabelEXT_params params;
 240     params.commandBuffer = commandBuffer;
 241     params.pLabelInfo = pLabelInfo;
 242     UNIX_CALL(vkCmdBeginDebugUtilsLabelEXT, &params);
 243 }
 244
 245 void WINAPI vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
 246 {
 247     struct vkCmdBeginQuery_params params;
 248     params.commandBuffer = commandBuffer;
 249     params.queryPool = queryPool;
 250     params.query = query;
 251     params.flags = flags;
 252     UNIX_CALL(vkCmdBeginQuery, &params);
 253 }
 254
 255 void WINAPI vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
 256 {
 257     struct vkCmdBeginQueryIndexedEXT_params params;
 258     params.commandBuffer = commandBuffer;
 259     params.queryPool = queryPool;
 260     params.query = query;
 261     params.flags = flags;
 262     params.index = index;
 263     UNIX_CALL(vkCmdBeginQueryIndexedEXT, &params);
 264 }
 265
 266 void WINAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
 267 {
 268     struct vkCmdBeginRenderPass_params params;
 269     params.commandBuffer = commandBuffer;
 270     params.pRenderPassBegin = pRenderPassBegin;
 271     params.contents = contents;
 272     UNIX_CALL(vkCmdBeginRenderPass, &params);
 273 }
 274
 275 void WINAPI vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 276 {
 277     struct vkCmdBeginRenderPass2_params params;
 278     params.commandBuffer = commandBuffer;
 279     params.pRenderPassBegin = pRenderPassBegin;
 280     params.pSubpassBeginInfo = pSubpassBeginInfo;
 281     UNIX_CALL(vkCmdBeginRenderPass2, &params);
 282 }
 283
 284 void WINAPI vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 285 {
 286     struct vkCmdBeginRenderPass2KHR_params params;
 287     params.commandBuffer = commandBuffer;
 288     params.pRenderPassBegin = pRenderPassBegin;
 289     params.pSubpassBeginInfo = pSubpassBeginInfo;
 290     UNIX_CALL(vkCmdBeginRenderPass2KHR, &params);
 291 }
 292
 293 void WINAPI vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
 294 {
 295     struct vkCmdBeginRendering_params params;
 296     params.commandBuffer = commandBuffer;
 297     params.pRenderingInfo = pRenderingInfo;
 298     UNIX_CALL(vkCmdBeginRendering, &params);
 299 }
 300
 301 void WINAPI vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
 302 {
 303     struct vkCmdBeginRenderingKHR_params params;
 304     params.commandBuffer = commandBuffer;
 305     params.pRenderingInfo = pRenderingInfo;
 306     UNIX_CALL(vkCmdBeginRenderingKHR, &params);
 307 }
 308
 309 void WINAPI vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
 310 {
 311     struct vkCmdBeginTransformFeedbackEXT_params params;
 312     params.commandBuffer = commandBuffer;
 313     params.firstCounterBuffer = firstCounterBuffer;
 314     params.counterBufferCount = counterBufferCount;
 315     params.pCounterBuffers = pCounterBuffers;
 316     params.pCounterBufferOffsets = pCounterBufferOffsets;
 317     UNIX_CALL(vkCmdBeginTransformFeedbackEXT, &params);
 318 }
 319
 320 void WINAPI vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
 321 {
 322     struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params params;
 323     params.commandBuffer = commandBuffer;
 324     params.pipelineBindPoint = pipelineBindPoint;
 325     params.layout = layout;
 326     params.set = set;
 327     UNIX_CALL(vkCmdBindDescriptorBufferEmbeddedSamplersEXT, &params);
 328 }
 329
 330 void WINAPI vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
 331 {
 332     struct vkCmdBindDescriptorBuffersEXT_params params;
 333     params.commandBuffer = commandBuffer;
 334     params.bufferCount = bufferCount;
 335     params.pBindingInfos = pBindingInfos;
 336     UNIX_CALL(vkCmdBindDescriptorBuffersEXT, &params);
 337 }
 338
 339 void WINAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
 340 {
 341     struct vkCmdBindDescriptorSets_params params;
 342     params.commandBuffer = commandBuffer;
 343     params.pipelineBindPoint = pipelineBindPoint;
 344     params.layout = layout;
 345     params.firstSet = firstSet;
 346     params.descriptorSetCount = descriptorSetCount;
 347     params.pDescriptorSets = pDescriptorSets;
 348     params.dynamicOffsetCount = dynamicOffsetCount;
 349     params.pDynamicOffsets = pDynamicOffsets;
 350     UNIX_CALL(vkCmdBindDescriptorSets, &params);
 351 }
 352
 353 void WINAPI vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 354 {
 355     struct vkCmdBindIndexBuffer_params params;
 356     params.commandBuffer = commandBuffer;
 357     params.buffer = buffer;
 358     params.offset = offset;
 359     params.indexType = indexType;
 360     UNIX_CALL(vkCmdBindIndexBuffer, &params);
 361 }
 362
 363 void WINAPI vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
 364 {
 365     struct vkCmdBindIndexBuffer2KHR_params params;
 366     params.commandBuffer = commandBuffer;
 367     params.buffer = buffer;
 368     params.offset = offset;
 369     params.size = size;
 370     params.indexType = indexType;
 371     UNIX_CALL(vkCmdBindIndexBuffer2KHR, &params);
 372 }
 373
 374 void WINAPI vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
 375 {
 376     struct vkCmdBindInvocationMaskHUAWEI_params params;
 377     params.commandBuffer = commandBuffer;
 378     params.imageView = imageView;
 379     params.imageLayout = imageLayout;
 380     UNIX_CALL(vkCmdBindInvocationMaskHUAWEI, &params);
 381 }
 382
 383 void WINAPI vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 384 {
 385     struct vkCmdBindPipeline_params params;
 386     params.commandBuffer = commandBuffer;
 387     params.pipelineBindPoint = pipelineBindPoint;
 388     params.pipeline = pipeline;
 389     UNIX_CALL(vkCmdBindPipeline, &params);
 390 }
 391
 392 void WINAPI vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
 393 {
 394     struct vkCmdBindPipelineShaderGroupNV_params params;
 395     params.commandBuffer = commandBuffer;
 396     params.pipelineBindPoint = pipelineBindPoint;
 397     params.pipeline = pipeline;
 398     params.groupIndex = groupIndex;
 399     UNIX_CALL(vkCmdBindPipelineShaderGroupNV, &params);
 400 }
 401
 402 void WINAPI vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits *pStages, const VkShaderEXT *pShaders)
 403 {
 404     struct vkCmdBindShadersEXT_params params;
 405     params.commandBuffer = commandBuffer;
 406     params.stageCount = stageCount;
 407     params.pStages = pStages;
 408     params.pShaders = pShaders;
 409     UNIX_CALL(vkCmdBindShadersEXT, &params);
 410 }
 411
 412 void WINAPI vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
 413 {
 414     struct vkCmdBindShadingRateImageNV_params params;
 415     params.commandBuffer = commandBuffer;
 416     params.imageView = imageView;
 417     params.imageLayout = imageLayout;
 418     UNIX_CALL(vkCmdBindShadingRateImageNV, &params);
 419 }
 420
 421 void WINAPI vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
 422 {
 423     struct vkCmdBindTransformFeedbackBuffersEXT_params params;
 424     params.commandBuffer = commandBuffer;
 425     params.firstBinding = firstBinding;
 426     params.bindingCount = bindingCount;
 427     params.pBuffers = pBuffers;
 428     params.pOffsets = pOffsets;
 429     params.pSizes = pSizes;
 430     UNIX_CALL(vkCmdBindTransformFeedbackBuffersEXT, &params);
 431 }
 432
 433 void WINAPI vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
 434 {
 435     struct vkCmdBindVertexBuffers_params params;
 436     params.commandBuffer = commandBuffer;
 437     params.firstBinding = firstBinding;
 438     params.bindingCount = bindingCount;
 439     params.pBuffers = pBuffers;
 440     params.pOffsets = pOffsets;
 441     UNIX_CALL(vkCmdBindVertexBuffers, &params);
 442 }
 443
 444 void WINAPI vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
 445 {
 446     struct vkCmdBindVertexBuffers2_params params;
 447     params.commandBuffer = commandBuffer;
 448     params.firstBinding = firstBinding;
 449     params.bindingCount = bindingCount;
 450     params.pBuffers = pBuffers;
 451     params.pOffsets = pOffsets;
 452     params.pSizes = pSizes;
 453     params.pStrides = pStrides;
 454     UNIX_CALL(vkCmdBindVertexBuffers2, &params);
 455 }
 456
 457 void WINAPI vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
 458 {
 459     struct vkCmdBindVertexBuffers2EXT_params params;
 460     params.commandBuffer = commandBuffer;
 461     params.firstBinding = firstBinding;
 462     params.bindingCount = bindingCount;
 463     params.pBuffers = pBuffers;
 464     params.pOffsets = pOffsets;
 465     params.pSizes = pSizes;
 466     params.pStrides = pStrides;
 467     UNIX_CALL(vkCmdBindVertexBuffers2EXT, &params);
 468 }
 469
 470 void WINAPI vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
 471 {
 472     struct vkCmdBlitImage_params params;
 473     params.commandBuffer = commandBuffer;
 474     params.srcImage = srcImage;
 475     params.srcImageLayout = srcImageLayout;
 476     params.dstImage = dstImage;
 477     params.dstImageLayout = dstImageLayout;
 478     params.regionCount = regionCount;
 479     params.pRegions = pRegions;
 480     params.filter = filter;
 481     UNIX_CALL(vkCmdBlitImage, &params);
 482 }
 483
 484 void WINAPI vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
 485 {
 486     struct vkCmdBlitImage2_params params;
 487     params.commandBuffer = commandBuffer;
 488     params.pBlitImageInfo = pBlitImageInfo;
 489     UNIX_CALL(vkCmdBlitImage2, &params);
 490 }
 491
 492 void WINAPI vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
 493 {
 494     struct vkCmdBlitImage2KHR_params params;
 495     params.commandBuffer = commandBuffer;
 496     params.pBlitImageInfo = pBlitImageInfo;
 497     UNIX_CALL(vkCmdBlitImage2KHR, &params);
 498 }
 499
 500 void WINAPI vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
 501 {
 502     struct vkCmdBuildAccelerationStructureNV_params params;
 503     params.commandBuffer = commandBuffer;
 504     params.pInfo = pInfo;
 505     params.instanceData = instanceData;
 506     params.instanceOffset = instanceOffset;
 507     params.update = update;
 508     params.dst = dst;
 509     params.src = src;
 510     params.scratch = scratch;
 511     params.scratchOffset = scratchOffset;
 512     UNIX_CALL(vkCmdBuildAccelerationStructureNV, &params);
 513 }
 514
 515 void WINAPI vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts)
 516 {
 517     struct vkCmdBuildAccelerationStructuresIndirectKHR_params params;
 518     params.commandBuffer = commandBuffer;
 519     params.infoCount = infoCount;
 520     params.pInfos = pInfos;
 521     params.pIndirectDeviceAddresses = pIndirectDeviceAddresses;
 522     params.pIndirectStrides = pIndirectStrides;
 523     params.ppMaxPrimitiveCounts = ppMaxPrimitiveCounts;
 524     UNIX_CALL(vkCmdBuildAccelerationStructuresIndirectKHR, &params);
 525 }
 526
 527 void WINAPI vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 528 {
 529     struct vkCmdBuildAccelerationStructuresKHR_params params;
 530     params.commandBuffer = commandBuffer;
 531     params.infoCount = infoCount;
 532     params.pInfos = pInfos;
 533     params.ppBuildRangeInfos = ppBuildRangeInfos;
 534     UNIX_CALL(vkCmdBuildAccelerationStructuresKHR, &params);
 535 }
 536
 537 void WINAPI vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
 538 {
 539     struct vkCmdBuildMicromapsEXT_params params;
 540     params.commandBuffer = commandBuffer;
 541     params.infoCount = infoCount;
 542     params.pInfos = pInfos;
 543     UNIX_CALL(vkCmdBuildMicromapsEXT, &params);
 544 }
 545
 546 void WINAPI vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
 547 {
 548     struct vkCmdClearAttachments_params params;
 549     params.commandBuffer = commandBuffer;
 550     params.attachmentCount = attachmentCount;
 551     params.pAttachments = pAttachments;
 552     params.rectCount = rectCount;
 553     params.pRects = pRects;
 554     UNIX_CALL(vkCmdClearAttachments, &params);
 555 }
 556
 557 void WINAPI vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 558 {
 559     struct vkCmdClearColorImage_params params;
 560     params.commandBuffer = commandBuffer;
 561     params.image = image;
 562     params.imageLayout = imageLayout;
 563     params.pColor = pColor;
 564     params.rangeCount = rangeCount;
 565     params.pRanges = pRanges;
 566     UNIX_CALL(vkCmdClearColorImage, &params);
 567 }
 568
 569 void WINAPI vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 570 {
 571     struct vkCmdClearDepthStencilImage_params params;
 572     params.commandBuffer = commandBuffer;
 573     params.image = image;
 574     params.imageLayout = imageLayout;
 575     params.pDepthStencil = pDepthStencil;
 576     params.rangeCount = rangeCount;
 577     params.pRanges = pRanges;
 578     UNIX_CALL(vkCmdClearDepthStencilImage, &params);
 579 }
 580
 581 void WINAPI vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
 582 {
 583     struct vkCmdCopyAccelerationStructureKHR_params params;
 584     params.commandBuffer = commandBuffer;
 585     params.pInfo = pInfo;
 586     UNIX_CALL(vkCmdCopyAccelerationStructureKHR, &params);
 587 }
 588
 589 void WINAPI vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
 590 {
 591     struct vkCmdCopyAccelerationStructureNV_params params;
 592     params.commandBuffer = commandBuffer;
 593     params.dst = dst;
 594     params.src = src;
 595     params.mode = mode;
 596     UNIX_CALL(vkCmdCopyAccelerationStructureNV, &params);
 597 }
 598
 599 void WINAPI vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
 600 {
 601     struct vkCmdCopyAccelerationStructureToMemoryKHR_params params;
 602     params.commandBuffer = commandBuffer;
 603     params.pInfo = pInfo;
 604     UNIX_CALL(vkCmdCopyAccelerationStructureToMemoryKHR, &params);
 605 }
 606
 607 void WINAPI vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
 608 {
 609     struct vkCmdCopyBuffer_params params;
 610     params.commandBuffer = commandBuffer;
 611     params.srcBuffer = srcBuffer;
 612     params.dstBuffer = dstBuffer;
 613     params.regionCount = regionCount;
 614     params.pRegions = pRegions;
 615     UNIX_CALL(vkCmdCopyBuffer, &params);
 616 }
 617
 618 void WINAPI vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
 619 {
 620     struct vkCmdCopyBuffer2_params params;
 621     params.commandBuffer = commandBuffer;
 622     params.pCopyBufferInfo = pCopyBufferInfo;
 623     UNIX_CALL(vkCmdCopyBuffer2, &params);
 624 }
 625
 626 void WINAPI vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
 627 {
 628     struct vkCmdCopyBuffer2KHR_params params;
 629     params.commandBuffer = commandBuffer;
 630     params.pCopyBufferInfo = pCopyBufferInfo;
 631     UNIX_CALL(vkCmdCopyBuffer2KHR, &params);
 632 }
 633
 634 void WINAPI vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 635 {
 636     struct vkCmdCopyBufferToImage_params params;
 637     params.commandBuffer = commandBuffer;
 638     params.srcBuffer = srcBuffer;
 639     params.dstImage = dstImage;
 640     params.dstImageLayout = dstImageLayout;
 641     params.regionCount = regionCount;
 642     params.pRegions = pRegions;
 643     UNIX_CALL(vkCmdCopyBufferToImage, &params);
 644 }
 645
 646 void WINAPI vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
 647 {
 648     struct vkCmdCopyBufferToImage2_params params;
 649     params.commandBuffer = commandBuffer;
 650     params.pCopyBufferToImageInfo = pCopyBufferToImageInfo;
 651     UNIX_CALL(vkCmdCopyBufferToImage2, &params);
 652 }
 653
 654 void WINAPI vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
 655 {
 656     struct vkCmdCopyBufferToImage2KHR_params params;
 657     params.commandBuffer = commandBuffer;
 658     params.pCopyBufferToImageInfo = pCopyBufferToImageInfo;
 659     UNIX_CALL(vkCmdCopyBufferToImage2KHR, &params);
 660 }
 661
 662 void WINAPI vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
 663 {
 664     struct vkCmdCopyImage_params params;
 665     params.commandBuffer = commandBuffer;
 666     params.srcImage = srcImage;
 667     params.srcImageLayout = srcImageLayout;
 668     params.dstImage = dstImage;
 669     params.dstImageLayout = dstImageLayout;
 670     params.regionCount = regionCount;
 671     params.pRegions = pRegions;
 672     UNIX_CALL(vkCmdCopyImage, &params);
 673 }
 674
 675 void WINAPI vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
 676 {
 677     struct vkCmdCopyImage2_params params;
 678     params.commandBuffer = commandBuffer;
 679     params.pCopyImageInfo = pCopyImageInfo;
 680     UNIX_CALL(vkCmdCopyImage2, &params);
 681 }
 682
 683 void WINAPI vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
 684 {
 685     struct vkCmdCopyImage2KHR_params params;
 686     params.commandBuffer = commandBuffer;
 687     params.pCopyImageInfo = pCopyImageInfo;
 688     UNIX_CALL(vkCmdCopyImage2KHR, &params);
 689 }
 690
 691 void WINAPI vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 692 {
 693     struct vkCmdCopyImageToBuffer_params params;
 694     params.commandBuffer = commandBuffer;
 695     params.srcImage = srcImage;
 696     params.srcImageLayout = srcImageLayout;
 697     params.dstBuffer = dstBuffer;
 698     params.regionCount = regionCount;
 699     params.pRegions = pRegions;
 700     UNIX_CALL(vkCmdCopyImageToBuffer, &params);
 701 }
 702
 703 void WINAPI vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
 704 {
 705     struct vkCmdCopyImageToBuffer2_params params;
 706     params.commandBuffer = commandBuffer;
 707     params.pCopyImageToBufferInfo = pCopyImageToBufferInfo;
 708     UNIX_CALL(vkCmdCopyImageToBuffer2, &params);
 709 }
 710
 711 void WINAPI vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
 712 {
 713     struct vkCmdCopyImageToBuffer2KHR_params params;
 714     params.commandBuffer = commandBuffer;
 715     params.pCopyImageToBufferInfo = pCopyImageToBufferInfo;
 716     UNIX_CALL(vkCmdCopyImageToBuffer2KHR, &params);
 717 }
 718
 719 void WINAPI vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
 720 {
 721     struct vkCmdCopyMemoryIndirectNV_params params;
 722     params.commandBuffer = commandBuffer;
 723     params.copyBufferAddress = copyBufferAddress;
 724     params.copyCount = copyCount;
 725     params.stride = stride;
 726     UNIX_CALL(vkCmdCopyMemoryIndirectNV, &params);
 727 }
 728
 729 void WINAPI vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
 730 {
 731     struct vkCmdCopyMemoryToAccelerationStructureKHR_params params;
 732     params.commandBuffer = commandBuffer;
 733     params.pInfo = pInfo;
 734     UNIX_CALL(vkCmdCopyMemoryToAccelerationStructureKHR, &params);
 735 }
 736
 737 void WINAPI vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
 738 {
 739     struct vkCmdCopyMemoryToImageIndirectNV_params params;
 740     params.commandBuffer = commandBuffer;
 741     params.copyBufferAddress = copyBufferAddress;
 742     params.copyCount = copyCount;
 743     params.stride = stride;
 744     params.dstImage = dstImage;
 745     params.dstImageLayout = dstImageLayout;
 746     params.pImageSubresources = pImageSubresources;
 747     UNIX_CALL(vkCmdCopyMemoryToImageIndirectNV, &params);
 748 }
 749
 750 void WINAPI vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
 751 {
 752     struct vkCmdCopyMemoryToMicromapEXT_params params;
 753     params.commandBuffer = commandBuffer;
 754     params.pInfo = pInfo;
 755     UNIX_CALL(vkCmdCopyMemoryToMicromapEXT, &params);
 756 }
 757
 758 void WINAPI vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
 759 {
 760     struct vkCmdCopyMicromapEXT_params params;
 761     params.commandBuffer = commandBuffer;
 762     params.pInfo = pInfo;
 763     UNIX_CALL(vkCmdCopyMicromapEXT, &params);
 764 }
 765
 766 void WINAPI vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
 767 {
 768     struct vkCmdCopyMicromapToMemoryEXT_params params;
 769     params.commandBuffer = commandBuffer;
 770     params.pInfo = pInfo;
 771     UNIX_CALL(vkCmdCopyMicromapToMemoryEXT, &params);
 772 }
 773
 774 void WINAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 775 {
 776     struct vkCmdCopyQueryPoolResults_params params;
 777     params.commandBuffer = commandBuffer;
 778     params.queryPool = queryPool;
 779     params.firstQuery = firstQuery;
 780     params.queryCount = queryCount;
 781     params.dstBuffer = dstBuffer;
 782     params.dstOffset = dstOffset;
 783     params.stride = stride;
 784     params.flags = flags;
 785     UNIX_CALL(vkCmdCopyQueryPoolResults, &params);
 786 }
 787
 788 void WINAPI vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
 789 {
 790     struct vkCmdCuLaunchKernelNVX_params params;
 791     params.commandBuffer = commandBuffer;
 792     params.pLaunchInfo = pLaunchInfo;
 793     UNIX_CALL(vkCmdCuLaunchKernelNVX, &params);
 794 }
 795
 796 void WINAPI vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 797 {
 798     struct vkCmdDebugMarkerBeginEXT_params params;
 799     params.commandBuffer = commandBuffer;
 800     params.pMarkerInfo = pMarkerInfo;
 801     UNIX_CALL(vkCmdDebugMarkerBeginEXT, &params);
 802 }
 803
 804 void WINAPI vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
 805 {
 806     struct vkCmdDebugMarkerEndEXT_params params;
 807     params.commandBuffer = commandBuffer;
 808     UNIX_CALL(vkCmdDebugMarkerEndEXT, &params);
 809 }
 810
 811 void WINAPI vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 812 {
 813     struct vkCmdDebugMarkerInsertEXT_params params;
 814     params.commandBuffer = commandBuffer;
 815     params.pMarkerInfo = pMarkerInfo;
 816     UNIX_CALL(vkCmdDebugMarkerInsertEXT, &params);
 817 }
 818
 819 void WINAPI vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
 820 {
 821     struct vkCmdDecompressMemoryIndirectCountNV_params params;
 822     params.commandBuffer = commandBuffer;
 823     params.indirectCommandsAddress = indirectCommandsAddress;
 824     params.indirectCommandsCountAddress = indirectCommandsCountAddress;
 825     params.stride = stride;
 826     UNIX_CALL(vkCmdDecompressMemoryIndirectCountNV, &params);
 827 }
 828
 829 void WINAPI vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
 830 {
 831     struct vkCmdDecompressMemoryNV_params params;
 832     params.commandBuffer = commandBuffer;
 833     params.decompressRegionCount = decompressRegionCount;
 834     params.pDecompressMemoryRegions = pDecompressMemoryRegions;
 835     UNIX_CALL(vkCmdDecompressMemoryNV, &params);
 836 }
 837
 838 void WINAPI vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 839 {
 840     struct vkCmdDispatch_params params;
 841     params.commandBuffer = commandBuffer;
 842     params.groupCountX = groupCountX;
 843     params.groupCountY = groupCountY;
 844     params.groupCountZ = groupCountZ;
 845     UNIX_CALL(vkCmdDispatch, &params);
 846 }
 847
 848 void WINAPI vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 849 {
 850     struct vkCmdDispatchBase_params params;
 851     params.commandBuffer = commandBuffer;
 852     params.baseGroupX = baseGroupX;
 853     params.baseGroupY = baseGroupY;
 854     params.baseGroupZ = baseGroupZ;
 855     params.groupCountX = groupCountX;
 856     params.groupCountY = groupCountY;
 857     params.groupCountZ = groupCountZ;
 858     UNIX_CALL(vkCmdDispatchBase, &params);
 859 }
 860
 861 void WINAPI vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 862 {
 863     struct vkCmdDispatchBaseKHR_params params;
 864     params.commandBuffer = commandBuffer;
 865     params.baseGroupX = baseGroupX;
 866     params.baseGroupY = baseGroupY;
 867     params.baseGroupZ = baseGroupZ;
 868     params.groupCountX = groupCountX;
 869     params.groupCountY = groupCountY;
 870     params.groupCountZ = groupCountZ;
 871     UNIX_CALL(vkCmdDispatchBaseKHR, &params);
 872 }
 873
 874 void WINAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 875 {
 876     struct vkCmdDispatchIndirect_params params;
 877     params.commandBuffer = commandBuffer;
 878     params.buffer = buffer;
 879     params.offset = offset;
 880     UNIX_CALL(vkCmdDispatchIndirect, &params);
 881 }
 882
 883 void WINAPI vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 884 {
 885     struct vkCmdDraw_params params;
 886     params.commandBuffer = commandBuffer;
 887     params.vertexCount = vertexCount;
 888     params.instanceCount = instanceCount;
 889     params.firstVertex = firstVertex;
 890     params.firstInstance = firstInstance;
 891     UNIX_CALL(vkCmdDraw, &params);
 892 }
 893
 894 void WINAPI vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 895 {
 896     struct vkCmdDrawClusterHUAWEI_params params;
 897     params.commandBuffer = commandBuffer;
 898     params.groupCountX = groupCountX;
 899     params.groupCountY = groupCountY;
 900     params.groupCountZ = groupCountZ;
 901     UNIX_CALL(vkCmdDrawClusterHUAWEI, &params);
 902 }
 903
 904 void WINAPI vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 905 {
 906     struct vkCmdDrawClusterIndirectHUAWEI_params params;
 907     params.commandBuffer = commandBuffer;
 908     params.buffer = buffer;
 909     params.offset = offset;
 910     UNIX_CALL(vkCmdDrawClusterIndirectHUAWEI, &params);
 911 }
 912
 913 void WINAPI vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 914 {
 915     struct vkCmdDrawIndexed_params params;
 916     params.commandBuffer = commandBuffer;
 917     params.indexCount = indexCount;
 918     params.instanceCount = instanceCount;
 919     params.firstIndex = firstIndex;
 920     params.vertexOffset = vertexOffset;
 921     params.firstInstance = firstInstance;
 922     UNIX_CALL(vkCmdDrawIndexed, &params);
 923 }
 924
 925 void WINAPI vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 926 {
 927     struct vkCmdDrawIndexedIndirect_params params;
 928     params.commandBuffer = commandBuffer;
 929     params.buffer = buffer;
 930     params.offset = offset;
 931     params.drawCount = drawCount;
 932     params.stride = stride;
 933     UNIX_CALL(vkCmdDrawIndexedIndirect, &params);
 934 }
 935
 936 void WINAPI vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 937 {
 938     struct vkCmdDrawIndexedIndirectCount_params params;
 939     params.commandBuffer = commandBuffer;
 940     params.buffer = buffer;
 941     params.offset = offset;
 942     params.countBuffer = countBuffer;
 943     params.countBufferOffset = countBufferOffset;
 944     params.maxDrawCount = maxDrawCount;
 945     params.stride = stride;
 946     UNIX_CALL(vkCmdDrawIndexedIndirectCount, &params);
 947 }
 948
 949 void WINAPI vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 950 {
 951     struct vkCmdDrawIndexedIndirectCountAMD_params params;
 952     params.commandBuffer = commandBuffer;
 953     params.buffer = buffer;
 954     params.offset = offset;
 955     params.countBuffer = countBuffer;
 956     params.countBufferOffset = countBufferOffset;
 957     params.maxDrawCount = maxDrawCount;
 958     params.stride = stride;
 959     UNIX_CALL(vkCmdDrawIndexedIndirectCountAMD, &params);
 960 }
 961
 962 void WINAPI vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 963 {
 964     struct vkCmdDrawIndexedIndirectCountKHR_params params;
 965     params.commandBuffer = commandBuffer;
 966     params.buffer = buffer;
 967     params.offset = offset;
 968     params.countBuffer = countBuffer;
 969     params.countBufferOffset = countBufferOffset;
 970     params.maxDrawCount = maxDrawCount;
 971     params.stride = stride;
 972     UNIX_CALL(vkCmdDrawIndexedIndirectCountKHR, &params);
 973 }
 974
 975 void WINAPI vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 976 {
 977     struct vkCmdDrawIndirect_params params;
 978     params.commandBuffer = commandBuffer;
 979     params.buffer = buffer;
 980     params.offset = offset;
 981     params.drawCount = drawCount;
 982     params.stride = stride;
 983     UNIX_CALL(vkCmdDrawIndirect, &params);
 984 }
 985
 986 void WINAPI vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
 987 {
 988     struct vkCmdDrawIndirectByteCountEXT_params params;
 989     params.commandBuffer = commandBuffer;
 990     params.instanceCount = instanceCount;
 991     params.firstInstance = firstInstance;
 992     params.counterBuffer = counterBuffer;
 993     params.counterBufferOffset = counterBufferOffset;
 994     params.counterOffset = counterOffset;
 995     params.vertexStride = vertexStride;
 996     UNIX_CALL(vkCmdDrawIndirectByteCountEXT, &params);
 997 }
 998
 999 void WINAPI vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1000 {
1001     struct vkCmdDrawIndirectCount_params params;
1002     params.commandBuffer = commandBuffer;
1003     params.buffer = buffer;
1004     params.offset = offset;
1005     params.countBuffer = countBuffer;
1006     params.countBufferOffset = countBufferOffset;
1007     params.maxDrawCount = maxDrawCount;
1008     params.stride = stride;
1009     UNIX_CALL(vkCmdDrawIndirectCount, &params);
1010 }
1011
1012 void WINAPI vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1013 {
1014     struct vkCmdDrawIndirectCountAMD_params params;
1015     params.commandBuffer = commandBuffer;
1016     params.buffer = buffer;
1017     params.offset = offset;
1018     params.countBuffer = countBuffer;
1019     params.countBufferOffset = countBufferOffset;
1020     params.maxDrawCount = maxDrawCount;
1021     params.stride = stride;
1022     UNIX_CALL(vkCmdDrawIndirectCountAMD, &params);
1023 }
1024
1025 void WINAPI vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1026 {
1027     struct vkCmdDrawIndirectCountKHR_params params;
1028     params.commandBuffer = commandBuffer;
1029     params.buffer = buffer;
1030     params.offset = offset;
1031     params.countBuffer = countBuffer;
1032     params.countBufferOffset = countBufferOffset;
1033     params.maxDrawCount = maxDrawCount;
1034     params.stride = stride;
1035     UNIX_CALL(vkCmdDrawIndirectCountKHR, &params);
1036 }
1037
1038 void WINAPI vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
1039 {
1040     struct vkCmdDrawMeshTasksEXT_params params;
1041     params.commandBuffer = commandBuffer;
1042     params.groupCountX = groupCountX;
1043     params.groupCountY = groupCountY;
1044     params.groupCountZ = groupCountZ;
1045     UNIX_CALL(vkCmdDrawMeshTasksEXT, &params);
1046 }
1047
1048 void WINAPI vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1049 {
1050     struct vkCmdDrawMeshTasksIndirectCountEXT_params params;
1051     params.commandBuffer = commandBuffer;
1052     params.buffer = buffer;
1053     params.offset = offset;
1054     params.countBuffer = countBuffer;
1055     params.countBufferOffset = countBufferOffset;
1056     params.maxDrawCount = maxDrawCount;
1057     params.stride = stride;
1058     UNIX_CALL(vkCmdDrawMeshTasksIndirectCountEXT, &params);
1059 }
1060
1061 void WINAPI vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1062 {
1063     struct vkCmdDrawMeshTasksIndirectCountNV_params params;
1064     params.commandBuffer = commandBuffer;
1065     params.buffer = buffer;
1066     params.offset = offset;
1067     params.countBuffer = countBuffer;
1068     params.countBufferOffset = countBufferOffset;
1069     params.maxDrawCount = maxDrawCount;
1070     params.stride = stride;
1071     UNIX_CALL(vkCmdDrawMeshTasksIndirectCountNV, &params);
1072 }
1073
1074 void WINAPI vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
1075 {
1076     struct vkCmdDrawMeshTasksIndirectEXT_params params;
1077     params.commandBuffer = commandBuffer;
1078     params.buffer = buffer;
1079     params.offset = offset;
1080     params.drawCount = drawCount;
1081     params.stride = stride;
1082     UNIX_CALL(vkCmdDrawMeshTasksIndirectEXT, &params);
1083 }
1084
1085 void WINAPI vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
1086 {
1087     struct vkCmdDrawMeshTasksIndirectNV_params params;
1088     params.commandBuffer = commandBuffer;
1089     params.buffer = buffer;
1090     params.offset = offset;
1091     params.drawCount = drawCount;
1092     params.stride = stride;
1093     UNIX_CALL(vkCmdDrawMeshTasksIndirectNV, &params);
1094 }
1095
1096 void WINAPI vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
1097 {
1098     struct vkCmdDrawMeshTasksNV_params params;
1099     params.commandBuffer = commandBuffer;
1100     params.taskCount = taskCount;
1101     params.firstTask = firstTask;
1102     UNIX_CALL(vkCmdDrawMeshTasksNV, &params);
1103 }
1104
1105 void WINAPI vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
1106 {
1107     struct vkCmdDrawMultiEXT_params params;
1108     params.commandBuffer = commandBuffer;
1109     params.drawCount = drawCount;
1110     params.pVertexInfo = pVertexInfo;
1111     params.instanceCount = instanceCount;
1112     params.firstInstance = firstInstance;
1113     params.stride = stride;
1114     UNIX_CALL(vkCmdDrawMultiEXT, &params);
1115 }
1116
1117 void WINAPI vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
1118 {
1119     struct vkCmdDrawMultiIndexedEXT_params params;
1120     params.commandBuffer = commandBuffer;
1121     params.drawCount = drawCount;
1122     params.pIndexInfo = pIndexInfo;
1123     params.instanceCount = instanceCount;
1124     params.firstInstance = firstInstance;
1125     params.stride = stride;
1126     params.pVertexOffset = pVertexOffset;
1127     UNIX_CALL(vkCmdDrawMultiIndexedEXT, &params);
1128 }
1129
1130 void WINAPI vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
1131 {
1132     struct vkCmdEndConditionalRenderingEXT_params params;
1133     params.commandBuffer = commandBuffer;
1134     UNIX_CALL(vkCmdEndConditionalRenderingEXT, &params);
1135 }
1136
1137 void WINAPI vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
1138 {
1139     struct vkCmdEndDebugUtilsLabelEXT_params params;
1140     params.commandBuffer = commandBuffer;
1141     UNIX_CALL(vkCmdEndDebugUtilsLabelEXT, &params);
1142 }
1143
1144 void WINAPI vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
1145 {
1146     struct vkCmdEndQuery_params params;
1147     params.commandBuffer = commandBuffer;
1148     params.queryPool = queryPool;
1149     params.query = query;
1150     UNIX_CALL(vkCmdEndQuery, &params);
1151 }
1152
1153 void WINAPI vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
1154 {
1155     struct vkCmdEndQueryIndexedEXT_params params;
1156     params.commandBuffer = commandBuffer;
1157     params.queryPool = queryPool;
1158     params.query = query;
1159     params.index = index;
1160     UNIX_CALL(vkCmdEndQueryIndexedEXT, &params);
1161 }
1162
1163 void WINAPI vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
1164 {
1165     struct vkCmdEndRenderPass_params params;
1166     params.commandBuffer = commandBuffer;
1167     UNIX_CALL(vkCmdEndRenderPass, &params);
1168 }
1169
1170 void WINAPI vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
1171 {
1172     struct vkCmdEndRenderPass2_params params;
1173     params.commandBuffer = commandBuffer;
1174     params.pSubpassEndInfo = pSubpassEndInfo;
1175     UNIX_CALL(vkCmdEndRenderPass2, &params);
1176 }
1177
1178 void WINAPI vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
1179 {
1180     struct vkCmdEndRenderPass2KHR_params params;
1181     params.commandBuffer = commandBuffer;
1182     params.pSubpassEndInfo = pSubpassEndInfo;
1183     UNIX_CALL(vkCmdEndRenderPass2KHR, &params);
1184 }
1185
1186 void WINAPI vkCmdEndRendering(VkCommandBuffer commandBuffer)
1187 {
1188     struct vkCmdEndRendering_params params;
1189     params.commandBuffer = commandBuffer;
1190     UNIX_CALL(vkCmdEndRendering, &params);
1191 }
1192
1193 void WINAPI vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer)
1194 {
1195     struct vkCmdEndRenderingKHR_params params;
1196     params.commandBuffer = commandBuffer;
1197     UNIX_CALL(vkCmdEndRenderingKHR, &params);
1198 }
1199
1200 void WINAPI vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
1201 {
1202     struct vkCmdEndTransformFeedbackEXT_params params;
1203     params.commandBuffer = commandBuffer;
1204     params.firstCounterBuffer = firstCounterBuffer;
1205     params.counterBufferCount = counterBufferCount;
1206     params.pCounterBuffers = pCounterBuffers;
1207     params.pCounterBufferOffsets = pCounterBufferOffsets;
1208     UNIX_CALL(vkCmdEndTransformFeedbackEXT, &params);
1209 }
1210
1211 void WINAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
1212 {
1213     struct vkCmdExecuteCommands_params params;
1214     params.commandBuffer = commandBuffer;
1215     params.commandBufferCount = commandBufferCount;
1216     params.pCommandBuffers = pCommandBuffers;
1217     UNIX_CALL(vkCmdExecuteCommands, &params);
1218 }
1219
1220 void WINAPI vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
1221 {
1222     struct vkCmdExecuteGeneratedCommandsNV_params params;
1223     params.commandBuffer = commandBuffer;
1224     params.isPreprocessed = isPreprocessed;
1225     params.pGeneratedCommandsInfo = pGeneratedCommandsInfo;
1226     UNIX_CALL(vkCmdExecuteGeneratedCommandsNV, &params);
1227 }
1228
1229 void WINAPI vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
1230 {
1231     struct vkCmdFillBuffer_params params;
1232     params.commandBuffer = commandBuffer;
1233     params.dstBuffer = dstBuffer;
1234     params.dstOffset = dstOffset;
1235     params.size = size;
1236     params.data = data;
1237     UNIX_CALL(vkCmdFillBuffer, &params);
1238 }
1239
1240 void WINAPI vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
1241 {
1242     struct vkCmdInsertDebugUtilsLabelEXT_params params;
1243     params.commandBuffer = commandBuffer;
1244     params.pLabelInfo = pLabelInfo;
1245     UNIX_CALL(vkCmdInsertDebugUtilsLabelEXT, &params);
1246 }
1247
1248 void WINAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
1249 {
1250     struct vkCmdNextSubpass_params params;
1251     params.commandBuffer = commandBuffer;
1252     params.contents = contents;
1253     UNIX_CALL(vkCmdNextSubpass, &params);
1254 }
1255
1256 void WINAPI vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
1257 {
1258     struct vkCmdNextSubpass2_params params;
1259     params.commandBuffer = commandBuffer;
1260     params.pSubpassBeginInfo = pSubpassBeginInfo;
1261     params.pSubpassEndInfo = pSubpassEndInfo;
1262     UNIX_CALL(vkCmdNextSubpass2, &params);
1263 }
1264
1265 void WINAPI vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
1266 {
1267     struct vkCmdNextSubpass2KHR_params params;
1268     params.commandBuffer = commandBuffer;
1269     params.pSubpassBeginInfo = pSubpassBeginInfo;
1270     params.pSubpassEndInfo = pSubpassEndInfo;
1271     UNIX_CALL(vkCmdNextSubpass2KHR, &params);
1272 }
1273
1274 void WINAPI vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
1275 {
1276     struct vkCmdOpticalFlowExecuteNV_params params;
1277     params.commandBuffer = commandBuffer;
1278     params.session = session;
1279     params.pExecuteInfo = pExecuteInfo;
1280     UNIX_CALL(vkCmdOpticalFlowExecuteNV, &params);
1281 }
1282
1283 void WINAPI vkCmdPipelineBarrier(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)
1284 {
1285     struct vkCmdPipelineBarrier_params params;
1286     params.commandBuffer = commandBuffer;
1287     params.srcStageMask = srcStageMask;
1288     params.dstStageMask = dstStageMask;
1289     params.dependencyFlags = dependencyFlags;
1290     params.memoryBarrierCount = memoryBarrierCount;
1291     params.pMemoryBarriers = pMemoryBarriers;
1292     params.bufferMemoryBarrierCount = bufferMemoryBarrierCount;
1293     params.pBufferMemoryBarriers = pBufferMemoryBarriers;
1294     params.imageMemoryBarrierCount = imageMemoryBarrierCount;
1295     params.pImageMemoryBarriers = pImageMemoryBarriers;
1296     UNIX_CALL(vkCmdPipelineBarrier, &params);
1297 }
1298
1299 void WINAPI vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
1300 {
1301     struct vkCmdPipelineBarrier2_params params;
1302     params.commandBuffer = commandBuffer;
1303     params.pDependencyInfo = pDependencyInfo;
1304     UNIX_CALL(vkCmdPipelineBarrier2, &params);
1305 }
1306
1307 void WINAPI vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
1308 {
1309     struct vkCmdPipelineBarrier2KHR_params params;
1310     params.commandBuffer = commandBuffer;
1311     params.pDependencyInfo = pDependencyInfo;
1312     UNIX_CALL(vkCmdPipelineBarrier2KHR, &params);
1313 }
1314
1315 void WINAPI vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
1316 {
1317     struct vkCmdPreprocessGeneratedCommandsNV_params params;
1318     params.commandBuffer = commandBuffer;
1319     params.pGeneratedCommandsInfo = pGeneratedCommandsInfo;
1320     UNIX_CALL(vkCmdPreprocessGeneratedCommandsNV, &params);
1321 }
1322
1323 void WINAPI vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
1324 {
1325     struct vkCmdPushConstants_params params;
1326     params.commandBuffer = commandBuffer;
1327     params.layout = layout;
1328     params.stageFlags = stageFlags;
1329     params.offset = offset;
1330     params.size = size;
1331     params.pValues = pValues;
1332     UNIX_CALL(vkCmdPushConstants, &params);
1333 }
1334
1335 void WINAPI vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
1336 {
1337     struct vkCmdPushDescriptorSetKHR_params params;
1338     params.commandBuffer = commandBuffer;
1339     params.pipelineBindPoint = pipelineBindPoint;
1340     params.layout = layout;
1341     params.set = set;
1342     params.descriptorWriteCount = descriptorWriteCount;
1343     params.pDescriptorWrites = pDescriptorWrites;
1344     UNIX_CALL(vkCmdPushDescriptorSetKHR, &params);
1345 }
1346
1347 void WINAPI vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
1348 {
1349     struct vkCmdPushDescriptorSetWithTemplateKHR_params params;
1350     params.commandBuffer = commandBuffer;
1351     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
1352     params.layout = layout;
1353     params.set = set;
1354     params.pData = pData;
1355     UNIX_CALL(vkCmdPushDescriptorSetWithTemplateKHR, &params);
1356 }
1357
1358 void WINAPI vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1359 {
1360     struct vkCmdResetEvent_params params;
1361     params.commandBuffer = commandBuffer;
1362     params.event = event;
1363     params.stageMask = stageMask;
1364     UNIX_CALL(vkCmdResetEvent, &params);
1365 }
1366
1367 void WINAPI vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
1368 {
1369     struct vkCmdResetEvent2_params params;
1370     params.commandBuffer = commandBuffer;
1371     params.event = event;
1372     params.stageMask = stageMask;
1373     UNIX_CALL(vkCmdResetEvent2, &params);
1374 }
1375
1376 void WINAPI vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
1377 {
1378     struct vkCmdResetEvent2KHR_params params;
1379     params.commandBuffer = commandBuffer;
1380     params.event = event;
1381     params.stageMask = stageMask;
1382     UNIX_CALL(vkCmdResetEvent2KHR, &params);
1383 }
1384
1385 void WINAPI vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
1386 {
1387     struct vkCmdResetQueryPool_params params;
1388     params.commandBuffer = commandBuffer;
1389     params.queryPool = queryPool;
1390     params.firstQuery = firstQuery;
1391     params.queryCount = queryCount;
1392     UNIX_CALL(vkCmdResetQueryPool, &params);
1393 }
1394
1395 void WINAPI vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
1396 {
1397     struct vkCmdResolveImage_params params;
1398     params.commandBuffer = commandBuffer;
1399     params.srcImage = srcImage;
1400     params.srcImageLayout = srcImageLayout;
1401     params.dstImage = dstImage;
1402     params.dstImageLayout = dstImageLayout;
1403     params.regionCount = regionCount;
1404     params.pRegions = pRegions;
1405     UNIX_CALL(vkCmdResolveImage, &params);
1406 }
1407
1408 void WINAPI vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
1409 {
1410     struct vkCmdResolveImage2_params params;
1411     params.commandBuffer = commandBuffer;
1412     params.pResolveImageInfo = pResolveImageInfo;
1413     UNIX_CALL(vkCmdResolveImage2, &params);
1414 }
1415
1416 void WINAPI vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
1417 {
1418     struct vkCmdResolveImage2KHR_params params;
1419     params.commandBuffer = commandBuffer;
1420     params.pResolveImageInfo = pResolveImageInfo;
1421     UNIX_CALL(vkCmdResolveImage2KHR, &params);
1422 }
1423
1424 void WINAPI vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
1425 {
1426     struct vkCmdSetAlphaToCoverageEnableEXT_params params;
1427     params.commandBuffer = commandBuffer;
1428     params.alphaToCoverageEnable = alphaToCoverageEnable;
1429     UNIX_CALL(vkCmdSetAlphaToCoverageEnableEXT, &params);
1430 }
1431
1432 void WINAPI vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
1433 {
1434     struct vkCmdSetAlphaToOneEnableEXT_params params;
1435     params.commandBuffer = commandBuffer;
1436     params.alphaToOneEnable = alphaToOneEnable;
1437     UNIX_CALL(vkCmdSetAlphaToOneEnableEXT, &params);
1438 }
1439
1440 void WINAPI vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask)
1441 {
1442     struct vkCmdSetAttachmentFeedbackLoopEnableEXT_params params;
1443     params.commandBuffer = commandBuffer;
1444     params.aspectMask = aspectMask;
1445     UNIX_CALL(vkCmdSetAttachmentFeedbackLoopEnableEXT, &params);
1446 }
1447
1448 void WINAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
1449 {
1450     struct vkCmdSetBlendConstants_params params;
1451     params.commandBuffer = commandBuffer;
1452     params.blendConstants = blendConstants;
1453     UNIX_CALL(vkCmdSetBlendConstants, &params);
1454 }
1455
1456 void WINAPI vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
1457 {
1458     struct vkCmdSetCheckpointNV_params params;
1459     params.commandBuffer = commandBuffer;
1460     params.pCheckpointMarker = pCheckpointMarker;
1461     UNIX_CALL(vkCmdSetCheckpointNV, &params);
1462 }
1463
1464 void WINAPI vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
1465 {
1466     struct vkCmdSetCoarseSampleOrderNV_params params;
1467     params.commandBuffer = commandBuffer;
1468     params.sampleOrderType = sampleOrderType;
1469     params.customSampleOrderCount = customSampleOrderCount;
1470     params.pCustomSampleOrders = pCustomSampleOrders;
1471     UNIX_CALL(vkCmdSetCoarseSampleOrderNV, &params);
1472 }
1473
1474 void WINAPI vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
1475 {
1476     struct vkCmdSetColorBlendAdvancedEXT_params params;
1477     params.commandBuffer = commandBuffer;
1478     params.firstAttachment = firstAttachment;
1479     params.attachmentCount = attachmentCount;
1480     params.pColorBlendAdvanced = pColorBlendAdvanced;
1481     UNIX_CALL(vkCmdSetColorBlendAdvancedEXT, &params);
1482 }
1483
1484 void WINAPI vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
1485 {
1486     struct vkCmdSetColorBlendEnableEXT_params params;
1487     params.commandBuffer = commandBuffer;
1488     params.firstAttachment = firstAttachment;
1489     params.attachmentCount = attachmentCount;
1490     params.pColorBlendEnables = pColorBlendEnables;
1491     UNIX_CALL(vkCmdSetColorBlendEnableEXT, &params);
1492 }
1493
1494 void WINAPI vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
1495 {
1496     struct vkCmdSetColorBlendEquationEXT_params params;
1497     params.commandBuffer = commandBuffer;
1498     params.firstAttachment = firstAttachment;
1499     params.attachmentCount = attachmentCount;
1500     params.pColorBlendEquations = pColorBlendEquations;
1501     UNIX_CALL(vkCmdSetColorBlendEquationEXT, &params);
1502 }
1503
1504 void WINAPI vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
1505 {
1506     struct vkCmdSetColorWriteEnableEXT_params params;
1507     params.commandBuffer = commandBuffer;
1508     params.attachmentCount = attachmentCount;
1509     params.pColorWriteEnables = pColorWriteEnables;
1510     UNIX_CALL(vkCmdSetColorWriteEnableEXT, &params);
1511 }
1512
1513 void WINAPI vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
1514 {
1515     struct vkCmdSetColorWriteMaskEXT_params params;
1516     params.commandBuffer = commandBuffer;
1517     params.firstAttachment = firstAttachment;
1518     params.attachmentCount = attachmentCount;
1519     params.pColorWriteMasks = pColorWriteMasks;
1520     UNIX_CALL(vkCmdSetColorWriteMaskEXT, &params);
1521 }
1522
1523 void WINAPI vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
1524 {
1525     struct vkCmdSetConservativeRasterizationModeEXT_params params;
1526     params.commandBuffer = commandBuffer;
1527     params.conservativeRasterizationMode = conservativeRasterizationMode;
1528     UNIX_CALL(vkCmdSetConservativeRasterizationModeEXT, &params);
1529 }
1530
1531 void WINAPI vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
1532 {
1533     struct vkCmdSetCoverageModulationModeNV_params params;
1534     params.commandBuffer = commandBuffer;
1535     params.coverageModulationMode = coverageModulationMode;
1536     UNIX_CALL(vkCmdSetCoverageModulationModeNV, &params);
1537 }
1538
1539 void WINAPI vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
1540 {
1541     struct vkCmdSetCoverageModulationTableEnableNV_params params;
1542     params.commandBuffer = commandBuffer;
1543     params.coverageModulationTableEnable = coverageModulationTableEnable;
1544     UNIX_CALL(vkCmdSetCoverageModulationTableEnableNV, &params);
1545 }
1546
1547 void WINAPI vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
1548 {
1549     struct vkCmdSetCoverageModulationTableNV_params params;
1550     params.commandBuffer = commandBuffer;
1551     params.coverageModulationTableCount = coverageModulationTableCount;
1552     params.pCoverageModulationTable = pCoverageModulationTable;
1553     UNIX_CALL(vkCmdSetCoverageModulationTableNV, &params);
1554 }
1555
1556 void WINAPI vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
1557 {
1558     struct vkCmdSetCoverageReductionModeNV_params params;
1559     params.commandBuffer = commandBuffer;
1560     params.coverageReductionMode = coverageReductionMode;
1561     UNIX_CALL(vkCmdSetCoverageReductionModeNV, &params);
1562 }
1563
1564 void WINAPI vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
1565 {
1566     struct vkCmdSetCoverageToColorEnableNV_params params;
1567     params.commandBuffer = commandBuffer;
1568     params.coverageToColorEnable = coverageToColorEnable;
1569     UNIX_CALL(vkCmdSetCoverageToColorEnableNV, &params);
1570 }
1571
1572 void WINAPI vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
1573 {
1574     struct vkCmdSetCoverageToColorLocationNV_params params;
1575     params.commandBuffer = commandBuffer;
1576     params.coverageToColorLocation = coverageToColorLocation;
1577     UNIX_CALL(vkCmdSetCoverageToColorLocationNV, &params);
1578 }
1579
1580 void WINAPI vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
1581 {
1582     struct vkCmdSetCullMode_params params;
1583     params.commandBuffer = commandBuffer;
1584     params.cullMode = cullMode;
1585     UNIX_CALL(vkCmdSetCullMode, &params);
1586 }
1587
1588 void WINAPI vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
1589 {
1590     struct vkCmdSetCullModeEXT_params params;
1591     params.commandBuffer = commandBuffer;
1592     params.cullMode = cullMode;
1593     UNIX_CALL(vkCmdSetCullModeEXT, &params);
1594 }
1595
1596 void WINAPI vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
1597 {
1598     struct vkCmdSetDepthBias_params params;
1599     params.commandBuffer = commandBuffer;
1600     params.depthBiasConstantFactor = depthBiasConstantFactor;
1601     params.depthBiasClamp = depthBiasClamp;
1602     params.depthBiasSlopeFactor = depthBiasSlopeFactor;
1603     UNIX_CALL(vkCmdSetDepthBias, &params);
1604 }
1605
1606 void WINAPI vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT *pDepthBiasInfo)
1607 {
1608     struct vkCmdSetDepthBias2EXT_params params;
1609     params.commandBuffer = commandBuffer;
1610     params.pDepthBiasInfo = pDepthBiasInfo;
1611     UNIX_CALL(vkCmdSetDepthBias2EXT, &params);
1612 }
1613
1614 void WINAPI vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
1615 {
1616     struct vkCmdSetDepthBiasEnable_params params;
1617     params.commandBuffer = commandBuffer;
1618     params.depthBiasEnable = depthBiasEnable;
1619     UNIX_CALL(vkCmdSetDepthBiasEnable, &params);
1620 }
1621
1622 void WINAPI vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
1623 {
1624     struct vkCmdSetDepthBiasEnableEXT_params params;
1625     params.commandBuffer = commandBuffer;
1626     params.depthBiasEnable = depthBiasEnable;
1627     UNIX_CALL(vkCmdSetDepthBiasEnableEXT, &params);
1628 }
1629
1630 void WINAPI vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
1631 {
1632     struct vkCmdSetDepthBounds_params params;
1633     params.commandBuffer = commandBuffer;
1634     params.minDepthBounds = minDepthBounds;
1635     params.maxDepthBounds = maxDepthBounds;
1636     UNIX_CALL(vkCmdSetDepthBounds, &params);
1637 }
1638
1639 void WINAPI vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
1640 {
1641     struct vkCmdSetDepthBoundsTestEnable_params params;
1642     params.commandBuffer = commandBuffer;
1643     params.depthBoundsTestEnable = depthBoundsTestEnable;
1644     UNIX_CALL(vkCmdSetDepthBoundsTestEnable, &params);
1645 }
1646
1647 void WINAPI vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
1648 {
1649     struct vkCmdSetDepthBoundsTestEnableEXT_params params;
1650     params.commandBuffer = commandBuffer;
1651     params.depthBoundsTestEnable = depthBoundsTestEnable;
1652     UNIX_CALL(vkCmdSetDepthBoundsTestEnableEXT, &params);
1653 }
1654
1655 void WINAPI vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
1656 {
1657     struct vkCmdSetDepthClampEnableEXT_params params;
1658     params.commandBuffer = commandBuffer;
1659     params.depthClampEnable = depthClampEnable;
1660     UNIX_CALL(vkCmdSetDepthClampEnableEXT, &params);
1661 }
1662
1663 void WINAPI vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
1664 {
1665     struct vkCmdSetDepthClipEnableEXT_params params;
1666     params.commandBuffer = commandBuffer;
1667     params.depthClipEnable = depthClipEnable;
1668     UNIX_CALL(vkCmdSetDepthClipEnableEXT, &params);
1669 }
1670
1671 void WINAPI vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
1672 {
1673     struct vkCmdSetDepthClipNegativeOneToOneEXT_params params;
1674     params.commandBuffer = commandBuffer;
1675     params.negativeOneToOne = negativeOneToOne;
1676     UNIX_CALL(vkCmdSetDepthClipNegativeOneToOneEXT, &params);
1677 }
1678
1679 void WINAPI vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
1680 {
1681     struct vkCmdSetDepthCompareOp_params params;
1682     params.commandBuffer = commandBuffer;
1683     params.depthCompareOp = depthCompareOp;
1684     UNIX_CALL(vkCmdSetDepthCompareOp, &params);
1685 }
1686
1687 void WINAPI vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
1688 {
1689     struct vkCmdSetDepthCompareOpEXT_params params;
1690     params.commandBuffer = commandBuffer;
1691     params.depthCompareOp = depthCompareOp;
1692     UNIX_CALL(vkCmdSetDepthCompareOpEXT, &params);
1693 }
1694
1695 void WINAPI vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
1696 {
1697     struct vkCmdSetDepthTestEnable_params params;
1698     params.commandBuffer = commandBuffer;
1699     params.depthTestEnable = depthTestEnable;
1700     UNIX_CALL(vkCmdSetDepthTestEnable, &params);
1701 }
1702
1703 void WINAPI vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
1704 {
1705     struct vkCmdSetDepthTestEnableEXT_params params;
1706     params.commandBuffer = commandBuffer;
1707     params.depthTestEnable = depthTestEnable;
1708     UNIX_CALL(vkCmdSetDepthTestEnableEXT, &params);
1709 }
1710
1711 void WINAPI vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
1712 {
1713     struct vkCmdSetDepthWriteEnable_params params;
1714     params.commandBuffer = commandBuffer;
1715     params.depthWriteEnable = depthWriteEnable;
1716     UNIX_CALL(vkCmdSetDepthWriteEnable, &params);
1717 }
1718
1719 void WINAPI vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
1720 {
1721     struct vkCmdSetDepthWriteEnableEXT_params params;
1722     params.commandBuffer = commandBuffer;
1723     params.depthWriteEnable = depthWriteEnable;
1724     UNIX_CALL(vkCmdSetDepthWriteEnableEXT, &params);
1725 }
1726
1727 void WINAPI vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
1728 {
1729     struct vkCmdSetDescriptorBufferOffsetsEXT_params params;
1730     params.commandBuffer = commandBuffer;
1731     params.pipelineBindPoint = pipelineBindPoint;
1732     params.layout = layout;
1733     params.firstSet = firstSet;
1734     params.setCount = setCount;
1735     params.pBufferIndices = pBufferIndices;
1736     params.pOffsets = pOffsets;
1737     UNIX_CALL(vkCmdSetDescriptorBufferOffsetsEXT, &params);
1738 }
1739
1740 void WINAPI vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
1741 {
1742     struct vkCmdSetDeviceMask_params params;
1743     params.commandBuffer = commandBuffer;
1744     params.deviceMask = deviceMask;
1745     UNIX_CALL(vkCmdSetDeviceMask, &params);
1746 }
1747
1748 void WINAPI vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
1749 {
1750     struct vkCmdSetDeviceMaskKHR_params params;
1751     params.commandBuffer = commandBuffer;
1752     params.deviceMask = deviceMask;
1753     UNIX_CALL(vkCmdSetDeviceMaskKHR, &params);
1754 }
1755
1756 void WINAPI vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
1757 {
1758     struct vkCmdSetDiscardRectangleEXT_params params;
1759     params.commandBuffer = commandBuffer;
1760     params.firstDiscardRectangle = firstDiscardRectangle;
1761     params.discardRectangleCount = discardRectangleCount;
1762     params.pDiscardRectangles = pDiscardRectangles;
1763     UNIX_CALL(vkCmdSetDiscardRectangleEXT, &params);
1764 }
1765
1766 void WINAPI vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable)
1767 {
1768     struct vkCmdSetDiscardRectangleEnableEXT_params params;
1769     params.commandBuffer = commandBuffer;
1770     params.discardRectangleEnable = discardRectangleEnable;
1771     UNIX_CALL(vkCmdSetDiscardRectangleEnableEXT, &params);
1772 }
1773
1774 void WINAPI vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode)
1775 {
1776     struct vkCmdSetDiscardRectangleModeEXT_params params;
1777     params.commandBuffer = commandBuffer;
1778     params.discardRectangleMode = discardRectangleMode;
1779     UNIX_CALL(vkCmdSetDiscardRectangleModeEXT, &params);
1780 }
1781
1782 void WINAPI vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1783 {
1784     struct vkCmdSetEvent_params params;
1785     params.commandBuffer = commandBuffer;
1786     params.event = event;
1787     params.stageMask = stageMask;
1788     UNIX_CALL(vkCmdSetEvent, &params);
1789 }
1790
1791 void WINAPI vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
1792 {
1793     struct vkCmdSetEvent2_params params;
1794     params.commandBuffer = commandBuffer;
1795     params.event = event;
1796     params.pDependencyInfo = pDependencyInfo;
1797     UNIX_CALL(vkCmdSetEvent2, &params);
1798 }
1799
1800 void WINAPI vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
1801 {
1802     struct vkCmdSetEvent2KHR_params params;
1803     params.commandBuffer = commandBuffer;
1804     params.event = event;
1805     params.pDependencyInfo = pDependencyInfo;
1806     UNIX_CALL(vkCmdSetEvent2KHR, &params);
1807 }
1808
1809 void WINAPI vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32 *pExclusiveScissorEnables)
1810 {
1811     struct vkCmdSetExclusiveScissorEnableNV_params params;
1812     params.commandBuffer = commandBuffer;
1813     params.firstExclusiveScissor = firstExclusiveScissor;
1814     params.exclusiveScissorCount = exclusiveScissorCount;
1815     params.pExclusiveScissorEnables = pExclusiveScissorEnables;
1816     UNIX_CALL(vkCmdSetExclusiveScissorEnableNV, &params);
1817 }
1818
1819 void WINAPI vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
1820 {
1821     struct vkCmdSetExclusiveScissorNV_params params;
1822     params.commandBuffer = commandBuffer;
1823     params.firstExclusiveScissor = firstExclusiveScissor;
1824     params.exclusiveScissorCount = exclusiveScissorCount;
1825     params.pExclusiveScissors = pExclusiveScissors;
1826     UNIX_CALL(vkCmdSetExclusiveScissorNV, &params);
1827 }
1828
1829 void WINAPI vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
1830 {
1831     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params params;
1832     params.commandBuffer = commandBuffer;
1833     params.extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize;
1834     UNIX_CALL(vkCmdSetExtraPrimitiveOverestimationSizeEXT, &params);
1835 }
1836
1837 void WINAPI vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
1838 {
1839     struct vkCmdSetFragmentShadingRateEnumNV_params params;
1840     params.commandBuffer = commandBuffer;
1841     params.shadingRate = shadingRate;
1842     params.combinerOps = combinerOps;
1843     UNIX_CALL(vkCmdSetFragmentShadingRateEnumNV, &params);
1844 }
1845
1846 void WINAPI vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
1847 {
1848     struct vkCmdSetFragmentShadingRateKHR_params params;
1849     params.commandBuffer = commandBuffer;
1850     params.pFragmentSize = pFragmentSize;
1851     params.combinerOps = combinerOps;
1852     UNIX_CALL(vkCmdSetFragmentShadingRateKHR, &params);
1853 }
1854
1855 void WINAPI vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
1856 {
1857     struct vkCmdSetFrontFace_params params;
1858     params.commandBuffer = commandBuffer;
1859     params.frontFace = frontFace;
1860     UNIX_CALL(vkCmdSetFrontFace, &params);
1861 }
1862
1863 void WINAPI vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
1864 {
1865     struct vkCmdSetFrontFaceEXT_params params;
1866     params.commandBuffer = commandBuffer;
1867     params.frontFace = frontFace;
1868     UNIX_CALL(vkCmdSetFrontFaceEXT, &params);
1869 }
1870
1871 void WINAPI vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
1872 {
1873     struct vkCmdSetLineRasterizationModeEXT_params params;
1874     params.commandBuffer = commandBuffer;
1875     params.lineRasterizationMode = lineRasterizationMode;
1876     UNIX_CALL(vkCmdSetLineRasterizationModeEXT, &params);
1877 }
1878
1879 void WINAPI vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
1880 {
1881     struct vkCmdSetLineStippleEXT_params params;
1882     params.commandBuffer = commandBuffer;
1883     params.lineStippleFactor = lineStippleFactor;
1884     params.lineStipplePattern = lineStipplePattern;
1885     UNIX_CALL(vkCmdSetLineStippleEXT, &params);
1886 }
1887
1888 void WINAPI vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
1889 {
1890     struct vkCmdSetLineStippleEnableEXT_params params;
1891     params.commandBuffer = commandBuffer;
1892     params.stippledLineEnable = stippledLineEnable;
1893     UNIX_CALL(vkCmdSetLineStippleEnableEXT, &params);
1894 }
1895
1896 void WINAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
1897 {
1898     struct vkCmdSetLineWidth_params params;
1899     params.commandBuffer = commandBuffer;
1900     params.lineWidth = lineWidth;
1901     UNIX_CALL(vkCmdSetLineWidth, &params);
1902 }
1903
1904 void WINAPI vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
1905 {
1906     struct vkCmdSetLogicOpEXT_params params;
1907     params.commandBuffer = commandBuffer;
1908     params.logicOp = logicOp;
1909     UNIX_CALL(vkCmdSetLogicOpEXT, &params);
1910 }
1911
1912 void WINAPI vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
1913 {
1914     struct vkCmdSetLogicOpEnableEXT_params params;
1915     params.commandBuffer = commandBuffer;
1916     params.logicOpEnable = logicOpEnable;
1917     UNIX_CALL(vkCmdSetLogicOpEnableEXT, &params);
1918 }
1919
1920 void WINAPI vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
1921 {
1922     struct vkCmdSetPatchControlPointsEXT_params params;
1923     params.commandBuffer = commandBuffer;
1924     params.patchControlPoints = patchControlPoints;
1925     UNIX_CALL(vkCmdSetPatchControlPointsEXT, &params);
1926 }
1927
1928 VkResult WINAPI vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
1929 {
1930     struct vkCmdSetPerformanceMarkerINTEL_params params;
1931     NTSTATUS status;
1932     params.commandBuffer = commandBuffer;
1933     params.pMarkerInfo = pMarkerInfo;
1934     status = UNIX_CALL(vkCmdSetPerformanceMarkerINTEL, &params);
1935     assert(!status && "vkCmdSetPerformanceMarkerINTEL");
1936     return params.result;
1937 }
1938
1939 VkResult WINAPI vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
1940 {
1941     struct vkCmdSetPerformanceOverrideINTEL_params params;
1942     NTSTATUS status;
1943     params.commandBuffer = commandBuffer;
1944     params.pOverrideInfo = pOverrideInfo;
1945     status = UNIX_CALL(vkCmdSetPerformanceOverrideINTEL, &params);
1946     assert(!status && "vkCmdSetPerformanceOverrideINTEL");
1947     return params.result;
1948 }
1949
1950 VkResult WINAPI vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
1951 {
1952     struct vkCmdSetPerformanceStreamMarkerINTEL_params params;
1953     NTSTATUS status;
1954     params.commandBuffer = commandBuffer;
1955     params.pMarkerInfo = pMarkerInfo;
1956     status = UNIX_CALL(vkCmdSetPerformanceStreamMarkerINTEL, &params);
1957     assert(!status && "vkCmdSetPerformanceStreamMarkerINTEL");
1958     return params.result;
1959 }
1960
1961 void WINAPI vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
1962 {
1963     struct vkCmdSetPolygonModeEXT_params params;
1964     params.commandBuffer = commandBuffer;
1965     params.polygonMode = polygonMode;
1966     UNIX_CALL(vkCmdSetPolygonModeEXT, &params);
1967 }
1968
1969 void WINAPI vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
1970 {
1971     struct vkCmdSetPrimitiveRestartEnable_params params;
1972     params.commandBuffer = commandBuffer;
1973     params.primitiveRestartEnable = primitiveRestartEnable;
1974     UNIX_CALL(vkCmdSetPrimitiveRestartEnable, &params);
1975 }
1976
1977 void WINAPI vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
1978 {
1979     struct vkCmdSetPrimitiveRestartEnableEXT_params params;
1980     params.commandBuffer = commandBuffer;
1981     params.primitiveRestartEnable = primitiveRestartEnable;
1982     UNIX_CALL(vkCmdSetPrimitiveRestartEnableEXT, &params);
1983 }
1984
1985 void WINAPI vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
1986 {
1987     struct vkCmdSetPrimitiveTopology_params params;
1988     params.commandBuffer = commandBuffer;
1989     params.primitiveTopology = primitiveTopology;
1990     UNIX_CALL(vkCmdSetPrimitiveTopology, &params);
1991 }
1992
1993 void WINAPI vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
1994 {
1995     struct vkCmdSetPrimitiveTopologyEXT_params params;
1996     params.commandBuffer = commandBuffer;
1997     params.primitiveTopology = primitiveTopology;
1998     UNIX_CALL(vkCmdSetPrimitiveTopologyEXT, &params);
1999 }
2000
2001 void WINAPI vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
2002 {
2003     struct vkCmdSetProvokingVertexModeEXT_params params;
2004     params.commandBuffer = commandBuffer;
2005     params.provokingVertexMode = provokingVertexMode;
2006     UNIX_CALL(vkCmdSetProvokingVertexModeEXT, &params);
2007 }
2008
2009 void WINAPI vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
2010 {
2011     struct vkCmdSetRasterizationSamplesEXT_params params;
2012     params.commandBuffer = commandBuffer;
2013     params.rasterizationSamples = rasterizationSamples;
2014     UNIX_CALL(vkCmdSetRasterizationSamplesEXT, &params);
2015 }
2016
2017 void WINAPI vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
2018 {
2019     struct vkCmdSetRasterizationStreamEXT_params params;
2020     params.commandBuffer = commandBuffer;
2021     params.rasterizationStream = rasterizationStream;
2022     UNIX_CALL(vkCmdSetRasterizationStreamEXT, &params);
2023 }
2024
2025 void WINAPI vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
2026 {
2027     struct vkCmdSetRasterizerDiscardEnable_params params;
2028     params.commandBuffer = commandBuffer;
2029     params.rasterizerDiscardEnable = rasterizerDiscardEnable;
2030     UNIX_CALL(vkCmdSetRasterizerDiscardEnable, &params);
2031 }
2032
2033 void WINAPI vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
2034 {
2035     struct vkCmdSetRasterizerDiscardEnableEXT_params params;
2036     params.commandBuffer = commandBuffer;
2037     params.rasterizerDiscardEnable = rasterizerDiscardEnable;
2038     UNIX_CALL(vkCmdSetRasterizerDiscardEnableEXT, &params);
2039 }
2040
2041 void WINAPI vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
2042 {
2043     struct vkCmdSetRayTracingPipelineStackSizeKHR_params params;
2044     params.commandBuffer = commandBuffer;
2045     params.pipelineStackSize = pipelineStackSize;
2046     UNIX_CALL(vkCmdSetRayTracingPipelineStackSizeKHR, &params);
2047 }
2048
2049 void WINAPI vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
2050 {
2051     struct vkCmdSetRepresentativeFragmentTestEnableNV_params params;
2052     params.commandBuffer = commandBuffer;
2053     params.representativeFragmentTestEnable = representativeFragmentTestEnable;
2054     UNIX_CALL(vkCmdSetRepresentativeFragmentTestEnableNV, &params);
2055 }
2056
2057 void WINAPI vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
2058 {
2059     struct vkCmdSetSampleLocationsEXT_params params;
2060     params.commandBuffer = commandBuffer;
2061     params.pSampleLocationsInfo = pSampleLocationsInfo;
2062     UNIX_CALL(vkCmdSetSampleLocationsEXT, &params);
2063 }
2064
2065 void WINAPI vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
2066 {
2067     struct vkCmdSetSampleLocationsEnableEXT_params params;
2068     params.commandBuffer = commandBuffer;
2069     params.sampleLocationsEnable = sampleLocationsEnable;
2070     UNIX_CALL(vkCmdSetSampleLocationsEnableEXT, &params);
2071 }
2072
2073 void WINAPI vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
2074 {
2075     struct vkCmdSetSampleMaskEXT_params params;
2076     params.commandBuffer = commandBuffer;
2077     params.samples = samples;
2078     params.pSampleMask = pSampleMask;
2079     UNIX_CALL(vkCmdSetSampleMaskEXT, &params);
2080 }
2081
2082 void WINAPI vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
2083 {
2084     struct vkCmdSetScissor_params params;
2085     params.commandBuffer = commandBuffer;
2086     params.firstScissor = firstScissor;
2087     params.scissorCount = scissorCount;
2088     params.pScissors = pScissors;
2089     UNIX_CALL(vkCmdSetScissor, &params);
2090 }
2091
2092 void WINAPI vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
2093 {
2094     struct vkCmdSetScissorWithCount_params params;
2095     params.commandBuffer = commandBuffer;
2096     params.scissorCount = scissorCount;
2097     params.pScissors = pScissors;
2098     UNIX_CALL(vkCmdSetScissorWithCount, &params);
2099 }
2100
2101 void WINAPI vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
2102 {
2103     struct vkCmdSetScissorWithCountEXT_params params;
2104     params.commandBuffer = commandBuffer;
2105     params.scissorCount = scissorCount;
2106     params.pScissors = pScissors;
2107     UNIX_CALL(vkCmdSetScissorWithCountEXT, &params);
2108 }
2109
2110 void WINAPI vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
2111 {
2112     struct vkCmdSetShadingRateImageEnableNV_params params;
2113     params.commandBuffer = commandBuffer;
2114     params.shadingRateImageEnable = shadingRateImageEnable;
2115     UNIX_CALL(vkCmdSetShadingRateImageEnableNV, &params);
2116 }
2117
2118 void WINAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
2119 {
2120     struct vkCmdSetStencilCompareMask_params params;
2121     params.commandBuffer = commandBuffer;
2122     params.faceMask = faceMask;
2123     params.compareMask = compareMask;
2124     UNIX_CALL(vkCmdSetStencilCompareMask, &params);
2125 }
2126
2127 void WINAPI vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
2128 {
2129     struct vkCmdSetStencilOp_params params;
2130     params.commandBuffer = commandBuffer;
2131     params.faceMask = faceMask;
2132     params.failOp = failOp;
2133     params.passOp = passOp;
2134     params.depthFailOp = depthFailOp;
2135     params.compareOp = compareOp;
2136     UNIX_CALL(vkCmdSetStencilOp, &params);
2137 }
2138
2139 void WINAPI vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
2140 {
2141     struct vkCmdSetStencilOpEXT_params params;
2142     params.commandBuffer = commandBuffer;
2143     params.faceMask = faceMask;
2144     params.failOp = failOp;
2145     params.passOp = passOp;
2146     params.depthFailOp = depthFailOp;
2147     params.compareOp = compareOp;
2148     UNIX_CALL(vkCmdSetStencilOpEXT, &params);
2149 }
2150
2151 void WINAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
2152 {
2153     struct vkCmdSetStencilReference_params params;
2154     params.commandBuffer = commandBuffer;
2155     params.faceMask = faceMask;
2156     params.reference = reference;
2157     UNIX_CALL(vkCmdSetStencilReference, &params);
2158 }
2159
2160 void WINAPI vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
2161 {
2162     struct vkCmdSetStencilTestEnable_params params;
2163     params.commandBuffer = commandBuffer;
2164     params.stencilTestEnable = stencilTestEnable;
2165     UNIX_CALL(vkCmdSetStencilTestEnable, &params);
2166 }
2167
2168 void WINAPI vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
2169 {
2170     struct vkCmdSetStencilTestEnableEXT_params params;
2171     params.commandBuffer = commandBuffer;
2172     params.stencilTestEnable = stencilTestEnable;
2173     UNIX_CALL(vkCmdSetStencilTestEnableEXT, &params);
2174 }
2175
2176 void WINAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
2177 {
2178     struct vkCmdSetStencilWriteMask_params params;
2179     params.commandBuffer = commandBuffer;
2180     params.faceMask = faceMask;
2181     params.writeMask = writeMask;
2182     UNIX_CALL(vkCmdSetStencilWriteMask, &params);
2183 }
2184
2185 void WINAPI vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
2186 {
2187     struct vkCmdSetTessellationDomainOriginEXT_params params;
2188     params.commandBuffer = commandBuffer;
2189     params.domainOrigin = domainOrigin;
2190     UNIX_CALL(vkCmdSetTessellationDomainOriginEXT, &params);
2191 }
2192
2193 void WINAPI vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
2194 {
2195     struct vkCmdSetVertexInputEXT_params params;
2196     params.commandBuffer = commandBuffer;
2197     params.vertexBindingDescriptionCount = vertexBindingDescriptionCount;
2198     params.pVertexBindingDescriptions = pVertexBindingDescriptions;
2199     params.vertexAttributeDescriptionCount = vertexAttributeDescriptionCount;
2200     params.pVertexAttributeDescriptions = pVertexAttributeDescriptions;
2201     UNIX_CALL(vkCmdSetVertexInputEXT, &params);
2202 }
2203
2204 void WINAPI vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
2205 {
2206     struct vkCmdSetViewport_params params;
2207     params.commandBuffer = commandBuffer;
2208     params.firstViewport = firstViewport;
2209     params.viewportCount = viewportCount;
2210     params.pViewports = pViewports;
2211     UNIX_CALL(vkCmdSetViewport, &params);
2212 }
2213
2214 void WINAPI vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
2215 {
2216     struct vkCmdSetViewportShadingRatePaletteNV_params params;
2217     params.commandBuffer = commandBuffer;
2218     params.firstViewport = firstViewport;
2219     params.viewportCount = viewportCount;
2220     params.pShadingRatePalettes = pShadingRatePalettes;
2221     UNIX_CALL(vkCmdSetViewportShadingRatePaletteNV, &params);
2222 }
2223
2224 void WINAPI vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
2225 {
2226     struct vkCmdSetViewportSwizzleNV_params params;
2227     params.commandBuffer = commandBuffer;
2228     params.firstViewport = firstViewport;
2229     params.viewportCount = viewportCount;
2230     params.pViewportSwizzles = pViewportSwizzles;
2231     UNIX_CALL(vkCmdSetViewportSwizzleNV, &params);
2232 }
2233
2234 void WINAPI vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
2235 {
2236     struct vkCmdSetViewportWScalingEnableNV_params params;
2237     params.commandBuffer = commandBuffer;
2238     params.viewportWScalingEnable = viewportWScalingEnable;
2239     UNIX_CALL(vkCmdSetViewportWScalingEnableNV, &params);
2240 }
2241
2242 void WINAPI vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
2243 {
2244     struct vkCmdSetViewportWScalingNV_params params;
2245     params.commandBuffer = commandBuffer;
2246     params.firstViewport = firstViewport;
2247     params.viewportCount = viewportCount;
2248     params.pViewportWScalings = pViewportWScalings;
2249     UNIX_CALL(vkCmdSetViewportWScalingNV, &params);
2250 }
2251
2252 void WINAPI vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
2253 {
2254     struct vkCmdSetViewportWithCount_params params;
2255     params.commandBuffer = commandBuffer;
2256     params.viewportCount = viewportCount;
2257     params.pViewports = pViewports;
2258     UNIX_CALL(vkCmdSetViewportWithCount, &params);
2259 }
2260
2261 void WINAPI vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
2262 {
2263     struct vkCmdSetViewportWithCountEXT_params params;
2264     params.commandBuffer = commandBuffer;
2265     params.viewportCount = viewportCount;
2266     params.pViewports = pViewports;
2267     UNIX_CALL(vkCmdSetViewportWithCountEXT, &params);
2268 }
2269
2270 void WINAPI vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer)
2271 {
2272     struct vkCmdSubpassShadingHUAWEI_params params;
2273     params.commandBuffer = commandBuffer;
2274     UNIX_CALL(vkCmdSubpassShadingHUAWEI, &params);
2275 }
2276
2277 void WINAPI vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
2278 {
2279     struct vkCmdTraceRaysIndirect2KHR_params params;
2280     params.commandBuffer = commandBuffer;
2281     params.indirectDeviceAddress = indirectDeviceAddress;
2282     UNIX_CALL(vkCmdTraceRaysIndirect2KHR, &params);
2283 }
2284
2285 void WINAPI vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
2286 {
2287     struct vkCmdTraceRaysIndirectKHR_params params;
2288     params.commandBuffer = commandBuffer;
2289     params.pRaygenShaderBindingTable = pRaygenShaderBindingTable;
2290     params.pMissShaderBindingTable = pMissShaderBindingTable;
2291     params.pHitShaderBindingTable = pHitShaderBindingTable;
2292     params.pCallableShaderBindingTable = pCallableShaderBindingTable;
2293     params.indirectDeviceAddress = indirectDeviceAddress;
2294     UNIX_CALL(vkCmdTraceRaysIndirectKHR, &params);
2295 }
2296
2297 void WINAPI vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
2298 {
2299     struct vkCmdTraceRaysKHR_params params;
2300     params.commandBuffer = commandBuffer;
2301     params.pRaygenShaderBindingTable = pRaygenShaderBindingTable;
2302     params.pMissShaderBindingTable = pMissShaderBindingTable;
2303     params.pHitShaderBindingTable = pHitShaderBindingTable;
2304     params.pCallableShaderBindingTable = pCallableShaderBindingTable;
2305     params.width = width;
2306     params.height = height;
2307     params.depth = depth;
2308     UNIX_CALL(vkCmdTraceRaysKHR, &params);
2309 }
2310
2311 void WINAPI vkCmdTraceRaysNV(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)
2312 {
2313     struct vkCmdTraceRaysNV_params params;
2314     params.commandBuffer = commandBuffer;
2315     params.raygenShaderBindingTableBuffer = raygenShaderBindingTableBuffer;
2316     params.raygenShaderBindingOffset = raygenShaderBindingOffset;
2317     params.missShaderBindingTableBuffer = missShaderBindingTableBuffer;
2318     params.missShaderBindingOffset = missShaderBindingOffset;
2319     params.missShaderBindingStride = missShaderBindingStride;
2320     params.hitShaderBindingTableBuffer = hitShaderBindingTableBuffer;
2321     params.hitShaderBindingOffset = hitShaderBindingOffset;
2322     params.hitShaderBindingStride = hitShaderBindingStride;
2323     params.callableShaderBindingTableBuffer = callableShaderBindingTableBuffer;
2324     params.callableShaderBindingOffset = callableShaderBindingOffset;
2325     params.callableShaderBindingStride = callableShaderBindingStride;
2326     params.width = width;
2327     params.height = height;
2328     params.depth = depth;
2329     UNIX_CALL(vkCmdTraceRaysNV, &params);
2330 }
2331
2332 void WINAPI vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
2333 {
2334     struct vkCmdUpdateBuffer_params params;
2335     params.commandBuffer = commandBuffer;
2336     params.dstBuffer = dstBuffer;
2337     params.dstOffset = dstOffset;
2338     params.dataSize = dataSize;
2339     params.pData = pData;
2340     UNIX_CALL(vkCmdUpdateBuffer, &params);
2341 }
2342
2343 void WINAPI vkCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
2344 {
2345     struct vkCmdUpdatePipelineIndirectBufferNV_params params;
2346     params.commandBuffer = commandBuffer;
2347     params.pipelineBindPoint = pipelineBindPoint;
2348     params.pipeline = pipeline;
2349     UNIX_CALL(vkCmdUpdatePipelineIndirectBufferNV, &params);
2350 }
2351
2352 void WINAPI vkCmdWaitEvents(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)
2353 {
2354     struct vkCmdWaitEvents_params params;
2355     params.commandBuffer = commandBuffer;
2356     params.eventCount = eventCount;
2357     params.pEvents = pEvents;
2358     params.srcStageMask = srcStageMask;
2359     params.dstStageMask = dstStageMask;
2360     params.memoryBarrierCount = memoryBarrierCount;
2361     params.pMemoryBarriers = pMemoryBarriers;
2362     params.bufferMemoryBarrierCount = bufferMemoryBarrierCount;
2363     params.pBufferMemoryBarriers = pBufferMemoryBarriers;
2364     params.imageMemoryBarrierCount = imageMemoryBarrierCount;
2365     params.pImageMemoryBarriers = pImageMemoryBarriers;
2366     UNIX_CALL(vkCmdWaitEvents, &params);
2367 }
2368
2369 void WINAPI vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
2370 {
2371     struct vkCmdWaitEvents2_params params;
2372     params.commandBuffer = commandBuffer;
2373     params.eventCount = eventCount;
2374     params.pEvents = pEvents;
2375     params.pDependencyInfos = pDependencyInfos;
2376     UNIX_CALL(vkCmdWaitEvents2, &params);
2377 }
2378
2379 void WINAPI vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
2380 {
2381     struct vkCmdWaitEvents2KHR_params params;
2382     params.commandBuffer = commandBuffer;
2383     params.eventCount = eventCount;
2384     params.pEvents = pEvents;
2385     params.pDependencyInfos = pDependencyInfos;
2386     UNIX_CALL(vkCmdWaitEvents2KHR, &params);
2387 }
2388
2389 void WINAPI vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2390 {
2391     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params params;
2392     params.commandBuffer = commandBuffer;
2393     params.accelerationStructureCount = accelerationStructureCount;
2394     params.pAccelerationStructures = pAccelerationStructures;
2395     params.queryType = queryType;
2396     params.queryPool = queryPool;
2397     params.firstQuery = firstQuery;
2398     UNIX_CALL(vkCmdWriteAccelerationStructuresPropertiesKHR, &params);
2399 }
2400
2401 void WINAPI vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2402 {
2403     struct vkCmdWriteAccelerationStructuresPropertiesNV_params params;
2404     params.commandBuffer = commandBuffer;
2405     params.accelerationStructureCount = accelerationStructureCount;
2406     params.pAccelerationStructures = pAccelerationStructures;
2407     params.queryType = queryType;
2408     params.queryPool = queryPool;
2409     params.firstQuery = firstQuery;
2410     UNIX_CALL(vkCmdWriteAccelerationStructuresPropertiesNV, &params);
2411 }
2412
2413 void WINAPI vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
2414 {
2415     struct vkCmdWriteBufferMarker2AMD_params params;
2416     params.commandBuffer = commandBuffer;
2417     params.stage = stage;
2418     params.dstBuffer = dstBuffer;
2419     params.dstOffset = dstOffset;
2420     params.marker = marker;
2421     UNIX_CALL(vkCmdWriteBufferMarker2AMD, &params);
2422 }
2423
2424 void WINAPI vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
2425 {
2426     struct vkCmdWriteBufferMarkerAMD_params params;
2427     params.commandBuffer = commandBuffer;
2428     params.pipelineStage = pipelineStage;
2429     params.dstBuffer = dstBuffer;
2430     params.dstOffset = dstOffset;
2431     params.marker = marker;
2432     UNIX_CALL(vkCmdWriteBufferMarkerAMD, &params);
2433 }
2434
2435 void WINAPI vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2436 {
2437     struct vkCmdWriteMicromapsPropertiesEXT_params params;
2438     params.commandBuffer = commandBuffer;
2439     params.micromapCount = micromapCount;
2440     params.pMicromaps = pMicromaps;
2441     params.queryType = queryType;
2442     params.queryPool = queryPool;
2443     params.firstQuery = firstQuery;
2444     UNIX_CALL(vkCmdWriteMicromapsPropertiesEXT, &params);
2445 }
2446
2447 void WINAPI vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
2448 {
2449     struct vkCmdWriteTimestamp_params params;
2450     params.commandBuffer = commandBuffer;
2451     params.pipelineStage = pipelineStage;
2452     params.queryPool = queryPool;
2453     params.query = query;
2454     UNIX_CALL(vkCmdWriteTimestamp, &params);
2455 }
2456
2457 void WINAPI vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
2458 {
2459     struct vkCmdWriteTimestamp2_params params;
2460     params.commandBuffer = commandBuffer;
2461     params.stage = stage;
2462     params.queryPool = queryPool;
2463     params.query = query;
2464     UNIX_CALL(vkCmdWriteTimestamp2, &params);
2465 }
2466
2467 void WINAPI vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
2468 {
2469     struct vkCmdWriteTimestamp2KHR_params params;
2470     params.commandBuffer = commandBuffer;
2471     params.stage = stage;
2472     params.queryPool = queryPool;
2473     params.query = query;
2474     UNIX_CALL(vkCmdWriteTimestamp2KHR, &params);
2475 }
2476
2477 VkResult WINAPI vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
2478 {
2479     struct vkCompileDeferredNV_params params;
2480     NTSTATUS status;
2481     params.device = device;
2482     params.pipeline = pipeline;
2483     params.shader = shader;
2484     status = UNIX_CALL(vkCompileDeferredNV, &params);
2485     assert(!status && "vkCompileDeferredNV");
2486     return params.result;
2487 }
2488
2489 VkResult WINAPI vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
2490 {
2491     struct vkCopyAccelerationStructureKHR_params params;
2492     NTSTATUS status;
2493     params.device = device;
2494     params.deferredOperation = deferredOperation;
2495     params.pInfo = pInfo;
2496     status = UNIX_CALL(vkCopyAccelerationStructureKHR, &params);
2497     assert(!status && "vkCopyAccelerationStructureKHR");
2498     return params.result;
2499 }
2500
2501 VkResult WINAPI vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
2502 {
2503     struct vkCopyAccelerationStructureToMemoryKHR_params params;
2504     NTSTATUS status;
2505     params.device = device;
2506     params.deferredOperation = deferredOperation;
2507     params.pInfo = pInfo;
2508     status = UNIX_CALL(vkCopyAccelerationStructureToMemoryKHR, &params);
2509     assert(!status && "vkCopyAccelerationStructureToMemoryKHR");
2510     return params.result;
2511 }
2512
2513 VkResult WINAPI vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfoEXT *pCopyImageToImageInfo)
2514 {
2515     struct vkCopyImageToImageEXT_params params;
2516     NTSTATUS status;
2517     params.device = device;
2518     params.pCopyImageToImageInfo = pCopyImageToImageInfo;
2519     status = UNIX_CALL(vkCopyImageToImageEXT, &params);
2520     assert(!status && "vkCopyImageToImageEXT");
2521     return params.result;
2522 }
2523
2524 VkResult WINAPI vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo)
2525 {
2526     struct vkCopyImageToMemoryEXT_params params;
2527     NTSTATUS status;
2528     params.device = device;
2529     params.pCopyImageToMemoryInfo = pCopyImageToMemoryInfo;
2530     status = UNIX_CALL(vkCopyImageToMemoryEXT, &params);
2531     assert(!status && "vkCopyImageToMemoryEXT");
2532     return params.result;
2533 }
2534
2535 VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
2536 {
2537     struct vkCopyMemoryToAccelerationStructureKHR_params params;
2538     NTSTATUS status;
2539     params.device = device;
2540     params.deferredOperation = deferredOperation;
2541     params.pInfo = pInfo;
2542     status = UNIX_CALL(vkCopyMemoryToAccelerationStructureKHR, &params);
2543     assert(!status && "vkCopyMemoryToAccelerationStructureKHR");
2544     return params.result;
2545 }
2546
2547 VkResult WINAPI vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo)
2548 {
2549     struct vkCopyMemoryToImageEXT_params params;
2550     NTSTATUS status;
2551     params.device = device;
2552     params.pCopyMemoryToImageInfo = pCopyMemoryToImageInfo;
2553     status = UNIX_CALL(vkCopyMemoryToImageEXT, &params);
2554     assert(!status && "vkCopyMemoryToImageEXT");
2555     return params.result;
2556 }
2557
2558 VkResult WINAPI vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
2559 {
2560     struct vkCopyMemoryToMicromapEXT_params params;
2561     NTSTATUS status;
2562     params.device = device;
2563     params.deferredOperation = deferredOperation;
2564     params.pInfo = pInfo;
2565     status = UNIX_CALL(vkCopyMemoryToMicromapEXT, &params);
2566     assert(!status && "vkCopyMemoryToMicromapEXT");
2567     return params.result;
2568 }
2569
2570 VkResult WINAPI vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
2571 {
2572     struct vkCopyMicromapEXT_params params;
2573     NTSTATUS status;
2574     params.device = device;
2575     params.deferredOperation = deferredOperation;
2576     params.pInfo = pInfo;
2577     status = UNIX_CALL(vkCopyMicromapEXT, &params);
2578     assert(!status && "vkCopyMicromapEXT");
2579     return params.result;
2580 }
2581
2582 VkResult WINAPI vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
2583 {
2584     struct vkCopyMicromapToMemoryEXT_params params;
2585     NTSTATUS status;
2586     params.device = device;
2587     params.deferredOperation = deferredOperation;
2588     params.pInfo = pInfo;
2589     status = UNIX_CALL(vkCopyMicromapToMemoryEXT, &params);
2590     assert(!status && "vkCopyMicromapToMemoryEXT");
2591     return params.result;
2592 }
2593
2594 VkResult WINAPI vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
2595 {
2596     struct vkCreateAccelerationStructureKHR_params params;
2597     NTSTATUS status;
2598     params.device = device;
2599     params.pCreateInfo = pCreateInfo;
2600     params.pAllocator = pAllocator;
2601     params.pAccelerationStructure = pAccelerationStructure;
2602     status = UNIX_CALL(vkCreateAccelerationStructureKHR, &params);
2603     assert(!status && "vkCreateAccelerationStructureKHR");
2604     return params.result;
2605 }
2606
2607 VkResult WINAPI vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
2608 {
2609     struct vkCreateAccelerationStructureNV_params params;
2610     NTSTATUS status;
2611     params.device = device;
2612     params.pCreateInfo = pCreateInfo;
2613     params.pAllocator = pAllocator;
2614     params.pAccelerationStructure = pAccelerationStructure;
2615     status = UNIX_CALL(vkCreateAccelerationStructureNV, &params);
2616     assert(!status && "vkCreateAccelerationStructureNV");
2617     return params.result;
2618 }
2619
2620 VkResult WINAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
2621 {
2622     struct vkCreateBuffer_params params;
2623     NTSTATUS status;
2624     params.device = device;
2625     params.pCreateInfo = pCreateInfo;
2626     params.pAllocator = pAllocator;
2627     params.pBuffer = pBuffer;
2628     status = UNIX_CALL(vkCreateBuffer, &params);
2629     assert(!status && "vkCreateBuffer");
2630     return params.result;
2631 }
2632
2633 VkResult WINAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
2634 {
2635     struct vkCreateBufferView_params params;
2636     NTSTATUS status;
2637     params.device = device;
2638     params.pCreateInfo = pCreateInfo;
2639     params.pAllocator = pAllocator;
2640     params.pView = pView;
2641     status = UNIX_CALL(vkCreateBufferView, &params);
2642     assert(!status && "vkCreateBufferView");
2643     return params.result;
2644 }
2645
2646 VkResult WINAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
2647 {
2648     struct vkCreateComputePipelines_params params;
2649     NTSTATUS status;
2650     params.device = device;
2651     params.pipelineCache = pipelineCache;
2652     params.createInfoCount = createInfoCount;
2653     params.pCreateInfos = pCreateInfos;
2654     params.pAllocator = pAllocator;
2655     params.pPipelines = pPipelines;
2656     status = UNIX_CALL(vkCreateComputePipelines, &params);
2657     assert(!status && "vkCreateComputePipelines");
2658     return params.result;
2659 }
2660
2661 VkResult WINAPI vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
2662 {
2663     struct vkCreateCuFunctionNVX_params params;
2664     NTSTATUS status;
2665     params.device = device;
2666     params.pCreateInfo = pCreateInfo;
2667     params.pAllocator = pAllocator;
2668     params.pFunction = pFunction;
2669     status = UNIX_CALL(vkCreateCuFunctionNVX, &params);
2670     assert(!status && "vkCreateCuFunctionNVX");
2671     return params.result;
2672 }
2673
2674 VkResult WINAPI vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
2675 {
2676     struct vkCreateCuModuleNVX_params params;
2677     NTSTATUS status;
2678     params.device = device;
2679     params.pCreateInfo = pCreateInfo;
2680     params.pAllocator = pAllocator;
2681     params.pModule = pModule;
2682     status = UNIX_CALL(vkCreateCuModuleNVX, &params);
2683     assert(!status && "vkCreateCuModuleNVX");
2684     return params.result;
2685 }
2686
2687 VkResult WINAPI vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
2688 {
2689     struct vkCreateDebugReportCallbackEXT_params params;
2690     NTSTATUS status;
2691     params.instance = instance;
2692     params.pCreateInfo = pCreateInfo;
2693     params.pAllocator = pAllocator;
2694     params.pCallback = pCallback;
2695     status = UNIX_CALL(vkCreateDebugReportCallbackEXT, &params);
2696     assert(!status && "vkCreateDebugReportCallbackEXT");
2697     return params.result;
2698 }
2699
2700 VkResult WINAPI vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
2701 {
2702     struct vkCreateDebugUtilsMessengerEXT_params params;
2703     NTSTATUS status;
2704     params.instance = instance;
2705     params.pCreateInfo = pCreateInfo;
2706     params.pAllocator = pAllocator;
2707     params.pMessenger = pMessenger;
2708     status = UNIX_CALL(vkCreateDebugUtilsMessengerEXT, &params);
2709     assert(!status && "vkCreateDebugUtilsMessengerEXT");
2710     return params.result;
2711 }
2712
2713 VkResult WINAPI vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
2714 {
2715     struct vkCreateDeferredOperationKHR_params params;
2716     NTSTATUS status;
2717     params.device = device;
2718     params.pAllocator = pAllocator;
2719     params.pDeferredOperation = pDeferredOperation;
2720     status = UNIX_CALL(vkCreateDeferredOperationKHR, &params);
2721     assert(!status && "vkCreateDeferredOperationKHR");
2722     return params.result;
2723 }
2724
2725 VkResult WINAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
2726 {
2727     struct vkCreateDescriptorPool_params params;
2728     NTSTATUS status;
2729     params.device = device;
2730     params.pCreateInfo = pCreateInfo;
2731     params.pAllocator = pAllocator;
2732     params.pDescriptorPool = pDescriptorPool;
2733     status = UNIX_CALL(vkCreateDescriptorPool, &params);
2734     assert(!status && "vkCreateDescriptorPool");
2735     return params.result;
2736 }
2737
2738 VkResult WINAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
2739 {
2740     struct vkCreateDescriptorSetLayout_params params;
2741     NTSTATUS status;
2742     params.device = device;
2743     params.pCreateInfo = pCreateInfo;
2744     params.pAllocator = pAllocator;
2745     params.pSetLayout = pSetLayout;
2746     status = UNIX_CALL(vkCreateDescriptorSetLayout, &params);
2747     assert(!status && "vkCreateDescriptorSetLayout");
2748     return params.result;
2749 }
2750
2751 VkResult WINAPI vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
2752 {
2753     struct vkCreateDescriptorUpdateTemplate_params params;
2754     NTSTATUS status;
2755     params.device = device;
2756     params.pCreateInfo = pCreateInfo;
2757     params.pAllocator = pAllocator;
2758     params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate;
2759     status = UNIX_CALL(vkCreateDescriptorUpdateTemplate, &params);
2760     assert(!status && "vkCreateDescriptorUpdateTemplate");
2761     return params.result;
2762 }
2763
2764 VkResult WINAPI vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
2765 {
2766     struct vkCreateDescriptorUpdateTemplateKHR_params params;
2767     NTSTATUS status;
2768     params.device = device;
2769     params.pCreateInfo = pCreateInfo;
2770     params.pAllocator = pAllocator;
2771     params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate;
2772     status = UNIX_CALL(vkCreateDescriptorUpdateTemplateKHR, &params);
2773     assert(!status && "vkCreateDescriptorUpdateTemplateKHR");
2774     return params.result;
2775 }
2776
2777 VkResult WINAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
2778 {
2779     struct vkCreateEvent_params params;
2780     NTSTATUS status;
2781     params.device = device;
2782     params.pCreateInfo = pCreateInfo;
2783     params.pAllocator = pAllocator;
2784     params.pEvent = pEvent;
2785     status = UNIX_CALL(vkCreateEvent, &params);
2786     assert(!status && "vkCreateEvent");
2787     return params.result;
2788 }
2789
2790 VkResult WINAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
2791 {
2792     struct vkCreateFence_params params;
2793     NTSTATUS status;
2794     params.device = device;
2795     params.pCreateInfo = pCreateInfo;
2796     params.pAllocator = pAllocator;
2797     params.pFence = pFence;
2798     status = UNIX_CALL(vkCreateFence, &params);
2799     assert(!status && "vkCreateFence");
2800     return params.result;
2801 }
2802
2803 VkResult WINAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
2804 {
2805     struct vkCreateFramebuffer_params params;
2806     NTSTATUS status;
2807     params.device = device;
2808     params.pCreateInfo = pCreateInfo;
2809     params.pAllocator = pAllocator;
2810     params.pFramebuffer = pFramebuffer;
2811     status = UNIX_CALL(vkCreateFramebuffer, &params);
2812     assert(!status && "vkCreateFramebuffer");
2813     return params.result;
2814 }
2815
2816 VkResult WINAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
2817 {
2818     struct vkCreateGraphicsPipelines_params params;
2819     NTSTATUS status;
2820     params.device = device;
2821     params.pipelineCache = pipelineCache;
2822     params.createInfoCount = createInfoCount;
2823     params.pCreateInfos = pCreateInfos;
2824     params.pAllocator = pAllocator;
2825     params.pPipelines = pPipelines;
2826     status = UNIX_CALL(vkCreateGraphicsPipelines, &params);
2827     assert(!status && "vkCreateGraphicsPipelines");
2828     return params.result;
2829 }
2830
2831 VkResult WINAPI vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
2832 {
2833     struct vkCreateImage_params params;
2834     NTSTATUS status;
2835     params.device = device;
2836     params.pCreateInfo = pCreateInfo;
2837     params.pAllocator = pAllocator;
2838     params.pImage = pImage;
2839     status = UNIX_CALL(vkCreateImage, &params);
2840     assert(!status && "vkCreateImage");
2841     return params.result;
2842 }
2843
2844 VkResult WINAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
2845 {
2846     struct vkCreateImageView_params params;
2847     NTSTATUS status;
2848     params.device = device;
2849     params.pCreateInfo = pCreateInfo;
2850     params.pAllocator = pAllocator;
2851     params.pView = pView;
2852     status = UNIX_CALL(vkCreateImageView, &params);
2853     assert(!status && "vkCreateImageView");
2854     return params.result;
2855 }
2856
2857 VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
2858 {
2859     struct vkCreateIndirectCommandsLayoutNV_params params;
2860     NTSTATUS status;
2861     params.device = device;
2862     params.pCreateInfo = pCreateInfo;
2863     params.pAllocator = pAllocator;
2864     params.pIndirectCommandsLayout = pIndirectCommandsLayout;
2865     status = UNIX_CALL(vkCreateIndirectCommandsLayoutNV, &params);
2866     assert(!status && "vkCreateIndirectCommandsLayoutNV");
2867     return params.result;
2868 }
2869
2870 VkResult WINAPI vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
2871 {
2872     struct vkCreateMicromapEXT_params params;
2873     NTSTATUS status;
2874     params.device = device;
2875     params.pCreateInfo = pCreateInfo;
2876     params.pAllocator = pAllocator;
2877     params.pMicromap = pMicromap;
2878     status = UNIX_CALL(vkCreateMicromapEXT, &params);
2879     assert(!status && "vkCreateMicromapEXT");
2880     return params.result;
2881 }
2882
2883 VkResult WINAPI vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
2884 {
2885     struct vkCreateOpticalFlowSessionNV_params params;
2886     NTSTATUS status;
2887     params.device = device;
2888     params.pCreateInfo = pCreateInfo;
2889     params.pAllocator = pAllocator;
2890     params.pSession = pSession;
2891     status = UNIX_CALL(vkCreateOpticalFlowSessionNV, &params);
2892     assert(!status && "vkCreateOpticalFlowSessionNV");
2893     return params.result;
2894 }
2895
2896 VkResult WINAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
2897 {
2898     struct vkCreatePipelineCache_params params;
2899     NTSTATUS status;
2900     params.device = device;
2901     params.pCreateInfo = pCreateInfo;
2902     params.pAllocator = pAllocator;
2903     params.pPipelineCache = pPipelineCache;
2904     status = UNIX_CALL(vkCreatePipelineCache, &params);
2905     assert(!status && "vkCreatePipelineCache");
2906     return params.result;
2907 }
2908
2909 VkResult WINAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
2910 {
2911     struct vkCreatePipelineLayout_params params;
2912     NTSTATUS status;
2913     params.device = device;
2914     params.pCreateInfo = pCreateInfo;
2915     params.pAllocator = pAllocator;
2916     params.pPipelineLayout = pPipelineLayout;
2917     status = UNIX_CALL(vkCreatePipelineLayout, &params);
2918     assert(!status && "vkCreatePipelineLayout");
2919     return params.result;
2920 }
2921
2922 VkResult WINAPI vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
2923 {
2924     struct vkCreatePrivateDataSlot_params params;
2925     NTSTATUS status;
2926     params.device = device;
2927     params.pCreateInfo = pCreateInfo;
2928     params.pAllocator = pAllocator;
2929     params.pPrivateDataSlot = pPrivateDataSlot;
2930     status = UNIX_CALL(vkCreatePrivateDataSlot, &params);
2931     assert(!status && "vkCreatePrivateDataSlot");
2932     return params.result;
2933 }
2934
2935 VkResult WINAPI vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
2936 {
2937     struct vkCreatePrivateDataSlotEXT_params params;
2938     NTSTATUS status;
2939     params.device = device;
2940     params.pCreateInfo = pCreateInfo;
2941     params.pAllocator = pAllocator;
2942     params.pPrivateDataSlot = pPrivateDataSlot;
2943     status = UNIX_CALL(vkCreatePrivateDataSlotEXT, &params);
2944     assert(!status && "vkCreatePrivateDataSlotEXT");
2945     return params.result;
2946 }
2947
2948 VkResult WINAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
2949 {
2950     struct vkCreateQueryPool_params params;
2951     NTSTATUS status;
2952     params.device = device;
2953     params.pCreateInfo = pCreateInfo;
2954     params.pAllocator = pAllocator;
2955     params.pQueryPool = pQueryPool;
2956     status = UNIX_CALL(vkCreateQueryPool, &params);
2957     assert(!status && "vkCreateQueryPool");
2958     return params.result;
2959 }
2960
2961 VkResult WINAPI vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
2962 {
2963     struct vkCreateRayTracingPipelinesKHR_params params;
2964     NTSTATUS status;
2965     params.device = device;
2966     params.deferredOperation = deferredOperation;
2967     params.pipelineCache = pipelineCache;
2968     params.createInfoCount = createInfoCount;
2969     params.pCreateInfos = pCreateInfos;
2970     params.pAllocator = pAllocator;
2971     params.pPipelines = pPipelines;
2972     status = UNIX_CALL(vkCreateRayTracingPipelinesKHR, &params);
2973     assert(!status && "vkCreateRayTracingPipelinesKHR");
2974     return params.result;
2975 }
2976
2977 VkResult WINAPI vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
2978 {
2979     struct vkCreateRayTracingPipelinesNV_params params;
2980     NTSTATUS status;
2981     params.device = device;
2982     params.pipelineCache = pipelineCache;
2983     params.createInfoCount = createInfoCount;
2984     params.pCreateInfos = pCreateInfos;
2985     params.pAllocator = pAllocator;
2986     params.pPipelines = pPipelines;
2987     status = UNIX_CALL(vkCreateRayTracingPipelinesNV, &params);
2988     assert(!status && "vkCreateRayTracingPipelinesNV");
2989     return params.result;
2990 }
2991
2992 VkResult WINAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
2993 {
2994     struct vkCreateRenderPass_params params;
2995     NTSTATUS status;
2996     params.device = device;
2997     params.pCreateInfo = pCreateInfo;
2998     params.pAllocator = pAllocator;
2999     params.pRenderPass = pRenderPass;
3000     status = UNIX_CALL(vkCreateRenderPass, &params);
3001     assert(!status && "vkCreateRenderPass");
3002     return params.result;
3003 }
3004
3005 VkResult WINAPI vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
3006 {
3007     struct vkCreateRenderPass2_params params;
3008     NTSTATUS status;
3009     params.device = device;
3010     params.pCreateInfo = pCreateInfo;
3011     params.pAllocator = pAllocator;
3012     params.pRenderPass = pRenderPass;
3013     status = UNIX_CALL(vkCreateRenderPass2, &params);
3014     assert(!status && "vkCreateRenderPass2");
3015     return params.result;
3016 }
3017
3018 VkResult WINAPI vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
3019 {
3020     struct vkCreateRenderPass2KHR_params params;
3021     NTSTATUS status;
3022     params.device = device;
3023     params.pCreateInfo = pCreateInfo;
3024     params.pAllocator = pAllocator;
3025     params.pRenderPass = pRenderPass;
3026     status = UNIX_CALL(vkCreateRenderPass2KHR, &params);
3027     assert(!status && "vkCreateRenderPass2KHR");
3028     return params.result;
3029 }
3030
3031 VkResult WINAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
3032 {
3033     struct vkCreateSampler_params params;
3034     NTSTATUS status;
3035     params.device = device;
3036     params.pCreateInfo = pCreateInfo;
3037     params.pAllocator = pAllocator;
3038     params.pSampler = pSampler;
3039     status = UNIX_CALL(vkCreateSampler, &params);
3040     assert(!status && "vkCreateSampler");
3041     return params.result;
3042 }
3043
3044 VkResult WINAPI vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
3045 {
3046     struct vkCreateSamplerYcbcrConversion_params params;
3047     NTSTATUS status;
3048     params.device = device;
3049     params.pCreateInfo = pCreateInfo;
3050     params.pAllocator = pAllocator;
3051     params.pYcbcrConversion = pYcbcrConversion;
3052     status = UNIX_CALL(vkCreateSamplerYcbcrConversion, &params);
3053     assert(!status && "vkCreateSamplerYcbcrConversion");
3054     return params.result;
3055 }
3056
3057 VkResult WINAPI vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
3058 {
3059     struct vkCreateSamplerYcbcrConversionKHR_params params;
3060     NTSTATUS status;
3061     params.device = device;
3062     params.pCreateInfo = pCreateInfo;
3063     params.pAllocator = pAllocator;
3064     params.pYcbcrConversion = pYcbcrConversion;
3065     status = UNIX_CALL(vkCreateSamplerYcbcrConversionKHR, &params);
3066     assert(!status && "vkCreateSamplerYcbcrConversionKHR");
3067     return params.result;
3068 }
3069
3070 VkResult WINAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
3071 {
3072     struct vkCreateSemaphore_params params;
3073     NTSTATUS status;
3074     params.device = device;
3075     params.pCreateInfo = pCreateInfo;
3076     params.pAllocator = pAllocator;
3077     params.pSemaphore = pSemaphore;
3078     status = UNIX_CALL(vkCreateSemaphore, &params);
3079     assert(!status && "vkCreateSemaphore");
3080     return params.result;
3081 }
3082
3083 VkResult WINAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
3084 {
3085     struct vkCreateShaderModule_params params;
3086     NTSTATUS status;
3087     params.device = device;
3088     params.pCreateInfo = pCreateInfo;
3089     params.pAllocator = pAllocator;
3090     params.pShaderModule = pShaderModule;
3091     status = UNIX_CALL(vkCreateShaderModule, &params);
3092     assert(!status && "vkCreateShaderModule");
3093     return params.result;
3094 }
3095
3096 VkResult WINAPI vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkShaderEXT *pShaders)
3097 {
3098     struct vkCreateShadersEXT_params params;
3099     NTSTATUS status;
3100     params.device = device;
3101     params.createInfoCount = createInfoCount;
3102     params.pCreateInfos = pCreateInfos;
3103     params.pAllocator = pAllocator;
3104     params.pShaders = pShaders;
3105     status = UNIX_CALL(vkCreateShadersEXT, &params);
3106     assert(!status && "vkCreateShadersEXT");
3107     return params.result;
3108 }
3109
3110 VkResult WINAPI vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
3111 {
3112     struct vkCreateSwapchainKHR_params params;
3113     NTSTATUS status;
3114     params.device = device;
3115     params.pCreateInfo = pCreateInfo;
3116     params.pAllocator = pAllocator;
3117     params.pSwapchain = pSwapchain;
3118     status = UNIX_CALL(vkCreateSwapchainKHR, &params);
3119     assert(!status && "vkCreateSwapchainKHR");
3120     return params.result;
3121 }
3122
3123 VkResult WINAPI vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
3124 {
3125     struct vkCreateValidationCacheEXT_params params;
3126     NTSTATUS status;
3127     params.device = device;
3128     params.pCreateInfo = pCreateInfo;
3129     params.pAllocator = pAllocator;
3130     params.pValidationCache = pValidationCache;
3131     status = UNIX_CALL(vkCreateValidationCacheEXT, &params);
3132     assert(!status && "vkCreateValidationCacheEXT");
3133     return params.result;
3134 }
3135
3136 VkResult WINAPI vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
3137 {
3138     struct vkCreateWin32SurfaceKHR_params params;
3139     NTSTATUS status;
3140     params.instance = instance;
3141     params.pCreateInfo = pCreateInfo;
3142     params.pAllocator = pAllocator;
3143     params.pSurface = pSurface;
3144     status = UNIX_CALL(vkCreateWin32SurfaceKHR, &params);
3145     assert(!status && "vkCreateWin32SurfaceKHR");
3146     return params.result;
3147 }
3148
3149 VkResult WINAPI vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
3150 {
3151     struct vkDebugMarkerSetObjectNameEXT_params params;
3152     NTSTATUS status;
3153     params.device = device;
3154     params.pNameInfo = pNameInfo;
3155     status = UNIX_CALL(vkDebugMarkerSetObjectNameEXT, &params);
3156     assert(!status && "vkDebugMarkerSetObjectNameEXT");
3157     return params.result;
3158 }
3159
3160 VkResult WINAPI vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
3161 {
3162     struct vkDebugMarkerSetObjectTagEXT_params params;
3163     NTSTATUS status;
3164     params.device = device;
3165     params.pTagInfo = pTagInfo;
3166     status = UNIX_CALL(vkDebugMarkerSetObjectTagEXT, &params);
3167     assert(!status && "vkDebugMarkerSetObjectTagEXT");
3168     return params.result;
3169 }
3170
3171 void WINAPI vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
3172 {
3173     struct vkDebugReportMessageEXT_params params;
3174     NTSTATUS status;
3175     params.instance = instance;
3176     params.flags = flags;
3177     params.objectType = objectType;
3178     params.object = object;
3179     params.location = location;
3180     params.messageCode = messageCode;
3181     params.pLayerPrefix = pLayerPrefix;
3182     params.pMessage = pMessage;
3183     status = UNIX_CALL(vkDebugReportMessageEXT, &params);
3184     assert(!status && "vkDebugReportMessageEXT");
3185 }
3186
3187 VkResult WINAPI vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
3188 {
3189     struct vkDeferredOperationJoinKHR_params params;
3190     NTSTATUS status;
3191     params.device = device;
3192     params.operation = operation;
3193     status = UNIX_CALL(vkDeferredOperationJoinKHR, &params);
3194     assert(!status && "vkDeferredOperationJoinKHR");
3195     return params.result;
3196 }
3197
3198 void WINAPI vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
3199 {
3200     struct vkDestroyAccelerationStructureKHR_params params;
3201     NTSTATUS status;
3202     params.device = device;
3203     params.accelerationStructure = accelerationStructure;
3204     params.pAllocator = pAllocator;
3205     status = UNIX_CALL(vkDestroyAccelerationStructureKHR, &params);
3206     assert(!status && "vkDestroyAccelerationStructureKHR");
3207 }
3208
3209 void WINAPI vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
3210 {
3211     struct vkDestroyAccelerationStructureNV_params params;
3212     NTSTATUS status;
3213     params.device = device;
3214     params.accelerationStructure = accelerationStructure;
3215     params.pAllocator = pAllocator;
3216     status = UNIX_CALL(vkDestroyAccelerationStructureNV, &params);
3217     assert(!status && "vkDestroyAccelerationStructureNV");
3218 }
3219
3220 void WINAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
3221 {
3222     struct vkDestroyBuffer_params params;
3223     NTSTATUS status;
3224     params.device = device;
3225     params.buffer = buffer;
3226     params.pAllocator = pAllocator;
3227     status = UNIX_CALL(vkDestroyBuffer, &params);
3228     assert(!status && "vkDestroyBuffer");
3229 }
3230
3231 void WINAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
3232 {
3233     struct vkDestroyBufferView_params params;
3234     NTSTATUS status;
3235     params.device = device;
3236     params.bufferView = bufferView;
3237     params.pAllocator = pAllocator;
3238     status = UNIX_CALL(vkDestroyBufferView, &params);
3239     assert(!status && "vkDestroyBufferView");
3240 }
3241
3242 void WINAPI vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
3243 {
3244     struct vkDestroyCuFunctionNVX_params params;
3245     NTSTATUS status;
3246     params.device = device;
3247     params.function = function;
3248     params.pAllocator = pAllocator;
3249     status = UNIX_CALL(vkDestroyCuFunctionNVX, &params);
3250     assert(!status && "vkDestroyCuFunctionNVX");
3251 }
3252
3253 void WINAPI vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
3254 {
3255     struct vkDestroyCuModuleNVX_params params;
3256     NTSTATUS status;
3257     params.device = device;
3258     params.module = module;
3259     params.pAllocator = pAllocator;
3260     status = UNIX_CALL(vkDestroyCuModuleNVX, &params);
3261     assert(!status && "vkDestroyCuModuleNVX");
3262 }
3263
3264 void WINAPI vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
3265 {
3266     struct vkDestroyDebugReportCallbackEXT_params params;
3267     NTSTATUS status;
3268     params.instance = instance;
3269     params.callback = callback;
3270     params.pAllocator = pAllocator;
3271     status = UNIX_CALL(vkDestroyDebugReportCallbackEXT, &params);
3272     assert(!status && "vkDestroyDebugReportCallbackEXT");
3273 }
3274
3275 void WINAPI vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
3276 {
3277     struct vkDestroyDebugUtilsMessengerEXT_params params;
3278     NTSTATUS status;
3279     params.instance = instance;
3280     params.messenger = messenger;
3281     params.pAllocator = pAllocator;
3282     status = UNIX_CALL(vkDestroyDebugUtilsMessengerEXT, &params);
3283     assert(!status && "vkDestroyDebugUtilsMessengerEXT");
3284 }
3285
3286 void WINAPI vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
3287 {
3288     struct vkDestroyDeferredOperationKHR_params params;
3289     NTSTATUS status;
3290     params.device = device;
3291     params.operation = operation;
3292     params.pAllocator = pAllocator;
3293     status = UNIX_CALL(vkDestroyDeferredOperationKHR, &params);
3294     assert(!status && "vkDestroyDeferredOperationKHR");
3295 }
3296
3297 void WINAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
3298 {
3299     struct vkDestroyDescriptorPool_params params;
3300     NTSTATUS status;
3301     params.device = device;
3302     params.descriptorPool = descriptorPool;
3303     params.pAllocator = pAllocator;
3304     status = UNIX_CALL(vkDestroyDescriptorPool, &params);
3305     assert(!status && "vkDestroyDescriptorPool");
3306 }
3307
3308 void WINAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
3309 {
3310     struct vkDestroyDescriptorSetLayout_params params;
3311     NTSTATUS status;
3312     params.device = device;
3313     params.descriptorSetLayout = descriptorSetLayout;
3314     params.pAllocator = pAllocator;
3315     status = UNIX_CALL(vkDestroyDescriptorSetLayout, &params);
3316     assert(!status && "vkDestroyDescriptorSetLayout");
3317 }
3318
3319 void WINAPI vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
3320 {
3321     struct vkDestroyDescriptorUpdateTemplate_params params;
3322     NTSTATUS status;
3323     params.device = device;
3324     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
3325     params.pAllocator = pAllocator;
3326     status = UNIX_CALL(vkDestroyDescriptorUpdateTemplate, &params);
3327     assert(!status && "vkDestroyDescriptorUpdateTemplate");
3328 }
3329
3330 void WINAPI vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
3331 {
3332     struct vkDestroyDescriptorUpdateTemplateKHR_params params;
3333     NTSTATUS status;
3334     params.device = device;
3335     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
3336     params.pAllocator = pAllocator;
3337     status = UNIX_CALL(vkDestroyDescriptorUpdateTemplateKHR, &params);
3338     assert(!status && "vkDestroyDescriptorUpdateTemplateKHR");
3339 }
3340
3341 void WINAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
3342 {
3343     struct vkDestroyEvent_params params;
3344     NTSTATUS status;
3345     params.device = device;
3346     params.event = event;
3347     params.pAllocator = pAllocator;
3348     status = UNIX_CALL(vkDestroyEvent, &params);
3349     assert(!status && "vkDestroyEvent");
3350 }
3351
3352 void WINAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
3353 {
3354     struct vkDestroyFence_params params;
3355     NTSTATUS status;
3356     params.device = device;
3357     params.fence = fence;
3358     params.pAllocator = pAllocator;
3359     status = UNIX_CALL(vkDestroyFence, &params);
3360     assert(!status && "vkDestroyFence");
3361 }
3362
3363 void WINAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
3364 {
3365     struct vkDestroyFramebuffer_params params;
3366     NTSTATUS status;
3367     params.device = device;
3368     params.framebuffer = framebuffer;
3369     params.pAllocator = pAllocator;
3370     status = UNIX_CALL(vkDestroyFramebuffer, &params);
3371     assert(!status && "vkDestroyFramebuffer");
3372 }
3373
3374 void WINAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
3375 {
3376     struct vkDestroyImage_params params;
3377     NTSTATUS status;
3378     params.device = device;
3379     params.image = image;
3380     params.pAllocator = pAllocator;
3381     status = UNIX_CALL(vkDestroyImage, &params);
3382     assert(!status && "vkDestroyImage");
3383 }
3384
3385 void WINAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
3386 {
3387     struct vkDestroyImageView_params params;
3388     NTSTATUS status;
3389     params.device = device;
3390     params.imageView = imageView;
3391     params.pAllocator = pAllocator;
3392     status = UNIX_CALL(vkDestroyImageView, &params);
3393     assert(!status && "vkDestroyImageView");
3394 }
3395
3396 void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
3397 {
3398     struct vkDestroyIndirectCommandsLayoutNV_params params;
3399     NTSTATUS status;
3400     params.device = device;
3401     params.indirectCommandsLayout = indirectCommandsLayout;
3402     params.pAllocator = pAllocator;
3403     status = UNIX_CALL(vkDestroyIndirectCommandsLayoutNV, &params);
3404     assert(!status && "vkDestroyIndirectCommandsLayoutNV");
3405 }
3406
3407 void WINAPI vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
3408 {
3409     struct vkDestroyMicromapEXT_params params;
3410     NTSTATUS status;
3411     params.device = device;
3412     params.micromap = micromap;
3413     params.pAllocator = pAllocator;
3414     status = UNIX_CALL(vkDestroyMicromapEXT, &params);
3415     assert(!status && "vkDestroyMicromapEXT");
3416 }
3417
3418 void WINAPI vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
3419 {
3420     struct vkDestroyOpticalFlowSessionNV_params params;
3421     NTSTATUS status;
3422     params.device = device;
3423     params.session = session;
3424     params.pAllocator = pAllocator;
3425     status = UNIX_CALL(vkDestroyOpticalFlowSessionNV, &params);
3426     assert(!status && "vkDestroyOpticalFlowSessionNV");
3427 }
3428
3429 void WINAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
3430 {
3431     struct vkDestroyPipeline_params params;
3432     NTSTATUS status;
3433     params.device = device;
3434     params.pipeline = pipeline;
3435     params.pAllocator = pAllocator;
3436     status = UNIX_CALL(vkDestroyPipeline, &params);
3437     assert(!status && "vkDestroyPipeline");
3438 }
3439
3440 void WINAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
3441 {
3442     struct vkDestroyPipelineCache_params params;
3443     NTSTATUS status;
3444     params.device = device;
3445     params.pipelineCache = pipelineCache;
3446     params.pAllocator = pAllocator;
3447     status = UNIX_CALL(vkDestroyPipelineCache, &params);
3448     assert(!status && "vkDestroyPipelineCache");
3449 }
3450
3451 void WINAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
3452 {
3453     struct vkDestroyPipelineLayout_params params;
3454     NTSTATUS status;
3455     params.device = device;
3456     params.pipelineLayout = pipelineLayout;
3457     params.pAllocator = pAllocator;
3458     status = UNIX_CALL(vkDestroyPipelineLayout, &params);
3459     assert(!status && "vkDestroyPipelineLayout");
3460 }
3461
3462 void WINAPI vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
3463 {
3464     struct vkDestroyPrivateDataSlot_params params;
3465     NTSTATUS status;
3466     params.device = device;
3467     params.privateDataSlot = privateDataSlot;
3468     params.pAllocator = pAllocator;
3469     status = UNIX_CALL(vkDestroyPrivateDataSlot, &params);
3470     assert(!status && "vkDestroyPrivateDataSlot");
3471 }
3472
3473 void WINAPI vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
3474 {
3475     struct vkDestroyPrivateDataSlotEXT_params params;
3476     NTSTATUS status;
3477     params.device = device;
3478     params.privateDataSlot = privateDataSlot;
3479     params.pAllocator = pAllocator;
3480     status = UNIX_CALL(vkDestroyPrivateDataSlotEXT, &params);
3481     assert(!status && "vkDestroyPrivateDataSlotEXT");
3482 }
3483
3484 void WINAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
3485 {
3486     struct vkDestroyQueryPool_params params;
3487     NTSTATUS status;
3488     params.device = device;
3489     params.queryPool = queryPool;
3490     params.pAllocator = pAllocator;
3491     status = UNIX_CALL(vkDestroyQueryPool, &params);
3492     assert(!status && "vkDestroyQueryPool");
3493 }
3494
3495 void WINAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
3496 {
3497     struct vkDestroyRenderPass_params params;
3498     NTSTATUS status;
3499     params.device = device;
3500     params.renderPass = renderPass;
3501     params.pAllocator = pAllocator;
3502     status = UNIX_CALL(vkDestroyRenderPass, &params);
3503     assert(!status && "vkDestroyRenderPass");
3504 }
3505
3506 void WINAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
3507 {
3508     struct vkDestroySampler_params params;
3509     NTSTATUS status;
3510     params.device = device;
3511     params.sampler = sampler;
3512     params.pAllocator = pAllocator;
3513     status = UNIX_CALL(vkDestroySampler, &params);
3514     assert(!status && "vkDestroySampler");
3515 }
3516
3517 void WINAPI vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
3518 {
3519     struct vkDestroySamplerYcbcrConversion_params params;
3520     NTSTATUS status;
3521     params.device = device;
3522     params.ycbcrConversion = ycbcrConversion;
3523     params.pAllocator = pAllocator;
3524     status = UNIX_CALL(vkDestroySamplerYcbcrConversion, &params);
3525     assert(!status && "vkDestroySamplerYcbcrConversion");
3526 }
3527
3528 void WINAPI vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
3529 {
3530     struct vkDestroySamplerYcbcrConversionKHR_params params;
3531     NTSTATUS status;
3532     params.device = device;
3533     params.ycbcrConversion = ycbcrConversion;
3534     params.pAllocator = pAllocator;
3535     status = UNIX_CALL(vkDestroySamplerYcbcrConversionKHR, &params);
3536     assert(!status && "vkDestroySamplerYcbcrConversionKHR");
3537 }
3538
3539 void WINAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
3540 {
3541     struct vkDestroySemaphore_params params;
3542     NTSTATUS status;
3543     params.device = device;
3544     params.semaphore = semaphore;
3545     params.pAllocator = pAllocator;
3546     status = UNIX_CALL(vkDestroySemaphore, &params);
3547     assert(!status && "vkDestroySemaphore");
3548 }
3549
3550 void WINAPI vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks *pAllocator)
3551 {
3552     struct vkDestroyShaderEXT_params params;
3553     NTSTATUS status;
3554     params.device = device;
3555     params.shader = shader;
3556     params.pAllocator = pAllocator;
3557     status = UNIX_CALL(vkDestroyShaderEXT, &params);
3558     assert(!status && "vkDestroyShaderEXT");
3559 }
3560
3561 void WINAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
3562 {
3563     struct vkDestroyShaderModule_params params;
3564     NTSTATUS status;
3565     params.device = device;
3566     params.shaderModule = shaderModule;
3567     params.pAllocator = pAllocator;
3568     status = UNIX_CALL(vkDestroyShaderModule, &params);
3569     assert(!status && "vkDestroyShaderModule");
3570 }
3571
3572 void WINAPI vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
3573 {
3574     struct vkDestroySurfaceKHR_params params;
3575     NTSTATUS status;
3576     params.instance = instance;
3577     params.surface = surface;
3578     params.pAllocator = pAllocator;
3579     status = UNIX_CALL(vkDestroySurfaceKHR, &params);
3580     assert(!status && "vkDestroySurfaceKHR");
3581 }
3582
3583 void WINAPI vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
3584 {
3585     struct vkDestroySwapchainKHR_params params;
3586     NTSTATUS status;
3587     params.device = device;
3588     params.swapchain = swapchain;
3589     params.pAllocator = pAllocator;
3590     status = UNIX_CALL(vkDestroySwapchainKHR, &params);
3591     assert(!status && "vkDestroySwapchainKHR");
3592 }
3593
3594 void WINAPI vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
3595 {
3596     struct vkDestroyValidationCacheEXT_params params;
3597     NTSTATUS status;
3598     params.device = device;
3599     params.validationCache = validationCache;
3600     params.pAllocator = pAllocator;
3601     status = UNIX_CALL(vkDestroyValidationCacheEXT, &params);
3602     assert(!status && "vkDestroyValidationCacheEXT");
3603 }
3604
3605 VkResult WINAPI vkDeviceWaitIdle(VkDevice device)
3606 {
3607     struct vkDeviceWaitIdle_params params;
3608     NTSTATUS status;
3609     params.device = device;
3610     status = UNIX_CALL(vkDeviceWaitIdle, &params);
3611     assert(!status && "vkDeviceWaitIdle");
3612     return params.result;
3613 }
3614
3615 VkResult WINAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer)
3616 {
3617     struct vkEndCommandBuffer_params params;
3618     NTSTATUS status;
3619     params.commandBuffer = commandBuffer;
3620     status = UNIX_CALL(vkEndCommandBuffer, &params);
3621     assert(!status && "vkEndCommandBuffer");
3622     return params.result;
3623 }
3624
3625 VkResult WINAPI vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
3626 {
3627     struct vkEnumerateDeviceExtensionProperties_params params;
3628     NTSTATUS status;
3629     params.physicalDevice = physicalDevice;
3630     params.pLayerName = pLayerName;
3631     params.pPropertyCount = pPropertyCount;
3632     params.pProperties = pProperties;
3633     status = UNIX_CALL(vkEnumerateDeviceExtensionProperties, &params);
3634     assert(!status && "vkEnumerateDeviceExtensionProperties");
3635     return params.result;
3636 }
3637
3638 VkResult WINAPI vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
3639 {
3640     struct vkEnumerateDeviceLayerProperties_params params;
3641     NTSTATUS status;
3642     params.physicalDevice = physicalDevice;
3643     params.pPropertyCount = pPropertyCount;
3644     params.pProperties = pProperties;
3645     status = UNIX_CALL(vkEnumerateDeviceLayerProperties, &params);
3646     assert(!status && "vkEnumerateDeviceLayerProperties");
3647     return params.result;
3648 }
3649
3650 VkResult WINAPI vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
3651 {
3652     struct vkEnumeratePhysicalDeviceGroups_params params;
3653     NTSTATUS status;
3654     params.instance = instance;
3655     params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount;
3656     params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties;
3657     status = UNIX_CALL(vkEnumeratePhysicalDeviceGroups, &params);
3658     assert(!status && "vkEnumeratePhysicalDeviceGroups");
3659     return params.result;
3660 }
3661
3662 VkResult WINAPI vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
3663 {
3664     struct vkEnumeratePhysicalDeviceGroupsKHR_params params;
3665     NTSTATUS status;
3666     params.instance = instance;
3667     params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount;
3668     params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties;
3669     status = UNIX_CALL(vkEnumeratePhysicalDeviceGroupsKHR, &params);
3670     assert(!status && "vkEnumeratePhysicalDeviceGroupsKHR");
3671     return params.result;
3672 }
3673
3674 VkResult WINAPI vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
3675 {
3676     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params params;
3677     NTSTATUS status;
3678     params.physicalDevice = physicalDevice;
3679     params.queueFamilyIndex = queueFamilyIndex;
3680     params.pCounterCount = pCounterCount;
3681     params.pCounters = pCounters;
3682     params.pCounterDescriptions = pCounterDescriptions;
3683     status = UNIX_CALL(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, &params);
3684     assert(!status && "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
3685     return params.result;
3686 }
3687
3688 VkResult WINAPI vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
3689 {
3690     struct vkEnumeratePhysicalDevices_params params;
3691     NTSTATUS status;
3692     params.instance = instance;
3693     params.pPhysicalDeviceCount = pPhysicalDeviceCount;
3694     params.pPhysicalDevices = pPhysicalDevices;
3695     status = UNIX_CALL(vkEnumeratePhysicalDevices, &params);
3696     assert(!status && "vkEnumeratePhysicalDevices");
3697     return params.result;
3698 }
3699
3700 VkResult WINAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
3701 {
3702     struct vkFlushMappedMemoryRanges_params params;
3703     NTSTATUS status;
3704     params.device = device;
3705     params.memoryRangeCount = memoryRangeCount;
3706     params.pMemoryRanges = pMemoryRanges;
3707     status = UNIX_CALL(vkFlushMappedMemoryRanges, &params);
3708     assert(!status && "vkFlushMappedMemoryRanges");
3709     return params.result;
3710 }
3711
3712 VkResult WINAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
3713 {
3714     struct vkFreeDescriptorSets_params params;
3715     NTSTATUS status;
3716     params.device = device;
3717     params.descriptorPool = descriptorPool;
3718     params.descriptorSetCount = descriptorSetCount;
3719     params.pDescriptorSets = pDescriptorSets;
3720     status = UNIX_CALL(vkFreeDescriptorSets, &params);
3721     assert(!status && "vkFreeDescriptorSets");
3722     return params.result;
3723 }
3724
3725 void WINAPI vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
3726 {
3727     struct vkFreeMemory_params params;
3728     NTSTATUS status;
3729     params.device = device;
3730     params.memory = memory;
3731     params.pAllocator = pAllocator;
3732     status = UNIX_CALL(vkFreeMemory, &params);
3733     assert(!status && "vkFreeMemory");
3734 }
3735
3736 void WINAPI vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
3737 {
3738     struct vkGetAccelerationStructureBuildSizesKHR_params params;
3739     NTSTATUS status;
3740     params.device = device;
3741     params.buildType = buildType;
3742     params.pBuildInfo = pBuildInfo;
3743     params.pMaxPrimitiveCounts = pMaxPrimitiveCounts;
3744     params.pSizeInfo = pSizeInfo;
3745     status = UNIX_CALL(vkGetAccelerationStructureBuildSizesKHR, &params);
3746     assert(!status && "vkGetAccelerationStructureBuildSizesKHR");
3747 }
3748
3749 VkDeviceAddress WINAPI vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
3750 {
3751     struct vkGetAccelerationStructureDeviceAddressKHR_params params;
3752     NTSTATUS status;
3753     params.device = device;
3754     params.pInfo = pInfo;
3755     status = UNIX_CALL(vkGetAccelerationStructureDeviceAddressKHR, &params);
3756     assert(!status && "vkGetAccelerationStructureDeviceAddressKHR");
3757     return params.result;
3758 }
3759
3760 VkResult WINAPI vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
3761 {
3762     struct vkGetAccelerationStructureHandleNV_params params;
3763     NTSTATUS status;
3764     params.device = device;
3765     params.accelerationStructure = accelerationStructure;
3766     params.dataSize = dataSize;
3767     params.pData = pData;
3768     status = UNIX_CALL(vkGetAccelerationStructureHandleNV, &params);
3769     assert(!status && "vkGetAccelerationStructureHandleNV");
3770     return params.result;
3771 }
3772
3773 void WINAPI vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
3774 {
3775     struct vkGetAccelerationStructureMemoryRequirementsNV_params params;
3776     NTSTATUS status;
3777     params.device = device;
3778     params.pInfo = pInfo;
3779     params.pMemoryRequirements = pMemoryRequirements;
3780     status = UNIX_CALL(vkGetAccelerationStructureMemoryRequirementsNV, &params);
3781     assert(!status && "vkGetAccelerationStructureMemoryRequirementsNV");
3782 }
3783
3784 VkResult WINAPI vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
3785 {
3786     struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params params;
3787     NTSTATUS status;
3788     params.device = device;
3789     params.pInfo = pInfo;
3790     params.pData = pData;
3791     status = UNIX_CALL(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, &params);
3792     assert(!status && "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT");
3793     return params.result;
3794 }
3795
3796 VkDeviceAddress WINAPI vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
3797 {
3798     struct vkGetBufferDeviceAddress_params params;
3799     NTSTATUS status;
3800     params.device = device;
3801     params.pInfo = pInfo;
3802     status = UNIX_CALL(vkGetBufferDeviceAddress, &params);
3803     assert(!status && "vkGetBufferDeviceAddress");
3804     return params.result;
3805 }
3806
3807 VkDeviceAddress WINAPI vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
3808 {
3809     struct vkGetBufferDeviceAddressEXT_params params;
3810     NTSTATUS status;
3811     params.device = device;
3812     params.pInfo = pInfo;
3813     status = UNIX_CALL(vkGetBufferDeviceAddressEXT, &params);
3814     assert(!status && "vkGetBufferDeviceAddressEXT");
3815     return params.result;
3816 }
3817
3818 VkDeviceAddress WINAPI vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
3819 {
3820     struct vkGetBufferDeviceAddressKHR_params params;
3821     NTSTATUS status;
3822     params.device = device;
3823     params.pInfo = pInfo;
3824     status = UNIX_CALL(vkGetBufferDeviceAddressKHR, &params);
3825     assert(!status && "vkGetBufferDeviceAddressKHR");
3826     return params.result;
3827 }
3828
3829 void WINAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
3830 {
3831     struct vkGetBufferMemoryRequirements_params params;
3832     NTSTATUS status;
3833     params.device = device;
3834     params.buffer = buffer;
3835     params.pMemoryRequirements = pMemoryRequirements;
3836     status = UNIX_CALL(vkGetBufferMemoryRequirements, &params);
3837     assert(!status && "vkGetBufferMemoryRequirements");
3838 }
3839
3840 void WINAPI vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
3841 {
3842     struct vkGetBufferMemoryRequirements2_params params;
3843     NTSTATUS status;
3844     params.device = device;
3845     params.pInfo = pInfo;
3846     params.pMemoryRequirements = pMemoryRequirements;
3847     status = UNIX_CALL(vkGetBufferMemoryRequirements2, &params);
3848     assert(!status && "vkGetBufferMemoryRequirements2");
3849 }
3850
3851 void WINAPI vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
3852 {
3853     struct vkGetBufferMemoryRequirements2KHR_params params;
3854     NTSTATUS status;
3855     params.device = device;
3856     params.pInfo = pInfo;
3857     params.pMemoryRequirements = pMemoryRequirements;
3858     status = UNIX_CALL(vkGetBufferMemoryRequirements2KHR, &params);
3859     assert(!status && "vkGetBufferMemoryRequirements2KHR");
3860 }
3861
3862 uint64_t WINAPI vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
3863 {
3864     struct vkGetBufferOpaqueCaptureAddress_params params;
3865     NTSTATUS status;
3866     params.device = device;
3867     params.pInfo = pInfo;
3868     status = UNIX_CALL(vkGetBufferOpaqueCaptureAddress, &params);
3869     assert(!status && "vkGetBufferOpaqueCaptureAddress");
3870     return params.result;
3871 }
3872
3873 uint64_t WINAPI vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
3874 {
3875     struct vkGetBufferOpaqueCaptureAddressKHR_params params;
3876     NTSTATUS status;
3877     params.device = device;
3878     params.pInfo = pInfo;
3879     status = UNIX_CALL(vkGetBufferOpaqueCaptureAddressKHR, &params);
3880     assert(!status && "vkGetBufferOpaqueCaptureAddressKHR");
3881     return params.result;
3882 }
3883
3884 VkResult WINAPI vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
3885 {
3886     struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params params;
3887     NTSTATUS status;
3888     params.device = device;
3889     params.pInfo = pInfo;
3890     params.pData = pData;
3891     status = UNIX_CALL(vkGetBufferOpaqueCaptureDescriptorDataEXT, &params);
3892     assert(!status && "vkGetBufferOpaqueCaptureDescriptorDataEXT");
3893     return params.result;
3894 }
3895
3896 VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
3897 {
3898     struct vkGetCalibratedTimestampsEXT_params params;
3899     NTSTATUS status;
3900     params.device = device;
3901     params.timestampCount = timestampCount;
3902     params.pTimestampInfos = pTimestampInfos;
3903     params.pTimestamps = pTimestamps;
3904     params.pMaxDeviation = pMaxDeviation;
3905     status = UNIX_CALL(vkGetCalibratedTimestampsEXT, &params);
3906     assert(!status && "vkGetCalibratedTimestampsEXT");
3907     return params.result;
3908 }
3909
3910 uint32_t WINAPI vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
3911 {
3912     struct vkGetDeferredOperationMaxConcurrencyKHR_params params;
3913     NTSTATUS status;
3914     params.device = device;
3915     params.operation = operation;
3916     status = UNIX_CALL(vkGetDeferredOperationMaxConcurrencyKHR, &params);
3917     assert(!status && "vkGetDeferredOperationMaxConcurrencyKHR");
3918     return params.result;
3919 }
3920
3921 VkResult WINAPI vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
3922 {
3923     struct vkGetDeferredOperationResultKHR_params params;
3924     NTSTATUS status;
3925     params.device = device;
3926     params.operation = operation;
3927     status = UNIX_CALL(vkGetDeferredOperationResultKHR, &params);
3928     assert(!status && "vkGetDeferredOperationResultKHR");
3929     return params.result;
3930 }
3931
3932 void WINAPI vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
3933 {
3934     struct vkGetDescriptorEXT_params params;
3935     params.device = device;
3936     params.pDescriptorInfo = pDescriptorInfo;
3937     params.dataSize = dataSize;
3938     params.pDescriptor = pDescriptor;
3939     UNIX_CALL(vkGetDescriptorEXT, &params);
3940 }
3941
3942 void WINAPI vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
3943 {
3944     struct vkGetDescriptorSetHostMappingVALVE_params params;
3945     NTSTATUS status;
3946     params.device = device;
3947     params.descriptorSet = descriptorSet;
3948     params.ppData = ppData;
3949     status = UNIX_CALL(vkGetDescriptorSetHostMappingVALVE, &params);
3950     assert(!status && "vkGetDescriptorSetHostMappingVALVE");
3951 }
3952
3953 void WINAPI vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
3954 {
3955     struct vkGetDescriptorSetLayoutBindingOffsetEXT_params params;
3956     NTSTATUS status;
3957     params.device = device;
3958     params.layout = layout;
3959     params.binding = binding;
3960     params.pOffset = pOffset;
3961     status = UNIX_CALL(vkGetDescriptorSetLayoutBindingOffsetEXT, &params);
3962     assert(!status && "vkGetDescriptorSetLayoutBindingOffsetEXT");
3963 }
3964
3965 void WINAPI vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
3966 {
3967     struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params params;
3968     NTSTATUS status;
3969     params.device = device;
3970     params.pBindingReference = pBindingReference;
3971     params.pHostMapping = pHostMapping;
3972     status = UNIX_CALL(vkGetDescriptorSetLayoutHostMappingInfoVALVE, &params);
3973     assert(!status && "vkGetDescriptorSetLayoutHostMappingInfoVALVE");
3974 }
3975
3976 void WINAPI vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
3977 {
3978     struct vkGetDescriptorSetLayoutSizeEXT_params params;
3979     NTSTATUS status;
3980     params.device = device;
3981     params.layout = layout;
3982     params.pLayoutSizeInBytes = pLayoutSizeInBytes;
3983     status = UNIX_CALL(vkGetDescriptorSetLayoutSizeEXT, &params);
3984     assert(!status && "vkGetDescriptorSetLayoutSizeEXT");
3985 }
3986
3987 void WINAPI vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
3988 {
3989     struct vkGetDescriptorSetLayoutSupport_params params;
3990     NTSTATUS status;
3991     params.device = device;
3992     params.pCreateInfo = pCreateInfo;
3993     params.pSupport = pSupport;
3994     status = UNIX_CALL(vkGetDescriptorSetLayoutSupport, &params);
3995     assert(!status && "vkGetDescriptorSetLayoutSupport");
3996 }
3997
3998 void WINAPI vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
3999 {
4000     struct vkGetDescriptorSetLayoutSupportKHR_params params;
4001     NTSTATUS status;
4002     params.device = device;
4003     params.pCreateInfo = pCreateInfo;
4004     params.pSupport = pSupport;
4005     status = UNIX_CALL(vkGetDescriptorSetLayoutSupportKHR, &params);
4006     assert(!status && "vkGetDescriptorSetLayoutSupportKHR");
4007 }
4008
4009 void WINAPI vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
4010 {
4011     struct vkGetDeviceAccelerationStructureCompatibilityKHR_params params;
4012     NTSTATUS status;
4013     params.device = device;
4014     params.pVersionInfo = pVersionInfo;
4015     params.pCompatibility = pCompatibility;
4016     status = UNIX_CALL(vkGetDeviceAccelerationStructureCompatibilityKHR, &params);
4017     assert(!status && "vkGetDeviceAccelerationStructureCompatibilityKHR");
4018 }
4019
4020 void WINAPI vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
4021 {
4022     struct vkGetDeviceBufferMemoryRequirements_params params;
4023     NTSTATUS status;
4024     params.device = device;
4025     params.pInfo = pInfo;
4026     params.pMemoryRequirements = pMemoryRequirements;
4027     status = UNIX_CALL(vkGetDeviceBufferMemoryRequirements, &params);
4028     assert(!status && "vkGetDeviceBufferMemoryRequirements");
4029 }
4030
4031 void WINAPI vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
4032 {
4033     struct vkGetDeviceBufferMemoryRequirementsKHR_params params;
4034     NTSTATUS status;
4035     params.device = device;
4036     params.pInfo = pInfo;
4037     params.pMemoryRequirements = pMemoryRequirements;
4038     status = UNIX_CALL(vkGetDeviceBufferMemoryRequirementsKHR, &params);
4039     assert(!status && "vkGetDeviceBufferMemoryRequirementsKHR");
4040 }
4041
4042 VkResult WINAPI vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
4043 {
4044     struct vkGetDeviceFaultInfoEXT_params params;
4045     NTSTATUS status;
4046     params.device = device;
4047     params.pFaultCounts = pFaultCounts;
4048     params.pFaultInfo = pFaultInfo;
4049     status = UNIX_CALL(vkGetDeviceFaultInfoEXT, &params);
4050     assert(!status && "vkGetDeviceFaultInfoEXT");
4051     return params.result;
4052 }
4053
4054 void WINAPI vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
4055 {
4056     struct vkGetDeviceGroupPeerMemoryFeatures_params params;
4057     NTSTATUS status;
4058     params.device = device;
4059     params.heapIndex = heapIndex;
4060     params.localDeviceIndex = localDeviceIndex;
4061     params.remoteDeviceIndex = remoteDeviceIndex;
4062     params.pPeerMemoryFeatures = pPeerMemoryFeatures;
4063     status = UNIX_CALL(vkGetDeviceGroupPeerMemoryFeatures, &params);
4064     assert(!status && "vkGetDeviceGroupPeerMemoryFeatures");
4065 }
4066
4067 void WINAPI vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
4068 {
4069     struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params params;
4070     NTSTATUS status;
4071     params.device = device;
4072     params.heapIndex = heapIndex;
4073     params.localDeviceIndex = localDeviceIndex;
4074     params.remoteDeviceIndex = remoteDeviceIndex;
4075     params.pPeerMemoryFeatures = pPeerMemoryFeatures;
4076     status = UNIX_CALL(vkGetDeviceGroupPeerMemoryFeaturesKHR, &params);
4077     assert(!status && "vkGetDeviceGroupPeerMemoryFeaturesKHR");
4078 }
4079
4080 VkResult WINAPI vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
4081 {
4082     struct vkGetDeviceGroupPresentCapabilitiesKHR_params params;
4083     NTSTATUS status;
4084     params.device = device;
4085     params.pDeviceGroupPresentCapabilities = pDeviceGroupPresentCapabilities;
4086     status = UNIX_CALL(vkGetDeviceGroupPresentCapabilitiesKHR, &params);
4087     assert(!status && "vkGetDeviceGroupPresentCapabilitiesKHR");
4088     return params.result;
4089 }
4090
4091 VkResult WINAPI vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
4092 {
4093     struct vkGetDeviceGroupSurfacePresentModesKHR_params params;
4094     NTSTATUS status;
4095     params.device = device;
4096     params.surface = surface;
4097     params.pModes = pModes;
4098     status = UNIX_CALL(vkGetDeviceGroupSurfacePresentModesKHR, &params);
4099     assert(!status && "vkGetDeviceGroupSurfacePresentModesKHR");
4100     return params.result;
4101 }
4102
4103 void WINAPI vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
4104 {
4105     struct vkGetDeviceImageMemoryRequirements_params params;
4106     NTSTATUS status;
4107     params.device = device;
4108     params.pInfo = pInfo;
4109     params.pMemoryRequirements = pMemoryRequirements;
4110     status = UNIX_CALL(vkGetDeviceImageMemoryRequirements, &params);
4111     assert(!status && "vkGetDeviceImageMemoryRequirements");
4112 }
4113
4114 void WINAPI vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
4115 {
4116     struct vkGetDeviceImageMemoryRequirementsKHR_params params;
4117     NTSTATUS status;
4118     params.device = device;
4119     params.pInfo = pInfo;
4120     params.pMemoryRequirements = pMemoryRequirements;
4121     status = UNIX_CALL(vkGetDeviceImageMemoryRequirementsKHR, &params);
4122     assert(!status && "vkGetDeviceImageMemoryRequirementsKHR");
4123 }
4124
4125 void WINAPI vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
4126 {
4127     struct vkGetDeviceImageSparseMemoryRequirements_params params;
4128     NTSTATUS status;
4129     params.device = device;
4130     params.pInfo = pInfo;
4131     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
4132     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
4133     status = UNIX_CALL(vkGetDeviceImageSparseMemoryRequirements, &params);
4134     assert(!status && "vkGetDeviceImageSparseMemoryRequirements");
4135 }
4136
4137 void WINAPI vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
4138 {
4139     struct vkGetDeviceImageSparseMemoryRequirementsKHR_params params;
4140     NTSTATUS status;
4141     params.device = device;
4142     params.pInfo = pInfo;
4143     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
4144     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
4145     status = UNIX_CALL(vkGetDeviceImageSparseMemoryRequirementsKHR, &params);
4146     assert(!status && "vkGetDeviceImageSparseMemoryRequirementsKHR");
4147 }
4148
4149 void WINAPI vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfoKHR *pInfo, VkSubresourceLayout2KHR *pLayout)
4150 {
4151     struct vkGetDeviceImageSubresourceLayoutKHR_params params;
4152     NTSTATUS status;
4153     params.device = device;
4154     params.pInfo = pInfo;
4155     params.pLayout = pLayout;
4156     status = UNIX_CALL(vkGetDeviceImageSubresourceLayoutKHR, &params);
4157     assert(!status && "vkGetDeviceImageSubresourceLayoutKHR");
4158 }
4159
4160 void WINAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
4161 {
4162     struct vkGetDeviceMemoryCommitment_params params;
4163     NTSTATUS status;
4164     params.device = device;
4165     params.memory = memory;
4166     params.pCommittedMemoryInBytes = pCommittedMemoryInBytes;
4167     status = UNIX_CALL(vkGetDeviceMemoryCommitment, &params);
4168     assert(!status && "vkGetDeviceMemoryCommitment");
4169 }
4170
4171 uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
4172 {
4173     struct vkGetDeviceMemoryOpaqueCaptureAddress_params params;
4174     NTSTATUS status;
4175     params.device = device;
4176     params.pInfo = pInfo;
4177     status = UNIX_CALL(vkGetDeviceMemoryOpaqueCaptureAddress, &params);
4178     assert(!status && "vkGetDeviceMemoryOpaqueCaptureAddress");
4179     return params.result;
4180 }
4181
4182 uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
4183 {
4184     struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params params;
4185     NTSTATUS status;
4186     params.device = device;
4187     params.pInfo = pInfo;
4188     status = UNIX_CALL(vkGetDeviceMemoryOpaqueCaptureAddressKHR, &params);
4189     assert(!status && "vkGetDeviceMemoryOpaqueCaptureAddressKHR");
4190     return params.result;
4191 }
4192
4193 void WINAPI vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
4194 {
4195     struct vkGetDeviceMicromapCompatibilityEXT_params params;
4196     NTSTATUS status;
4197     params.device = device;
4198     params.pVersionInfo = pVersionInfo;
4199     params.pCompatibility = pCompatibility;
4200     status = UNIX_CALL(vkGetDeviceMicromapCompatibilityEXT, &params);
4201     assert(!status && "vkGetDeviceMicromapCompatibilityEXT");
4202 }
4203
4204 void WINAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
4205 {
4206     struct vkGetDeviceQueue_params params;
4207     NTSTATUS status;
4208     params.device = device;
4209     params.queueFamilyIndex = queueFamilyIndex;
4210     params.queueIndex = queueIndex;
4211     params.pQueue = pQueue;
4212     status = UNIX_CALL(vkGetDeviceQueue, &params);
4213     assert(!status && "vkGetDeviceQueue");
4214 }
4215
4216 void WINAPI vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
4217 {
4218     struct vkGetDeviceQueue2_params params;
4219     NTSTATUS status;
4220     params.device = device;
4221     params.pQueueInfo = pQueueInfo;
4222     params.pQueue = pQueue;
4223     status = UNIX_CALL(vkGetDeviceQueue2, &params);
4224     assert(!status && "vkGetDeviceQueue2");
4225 }
4226
4227 VkResult WINAPI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
4228 {
4229     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params params;
4230     NTSTATUS status;
4231     params.device = device;
4232     params.renderpass = renderpass;
4233     params.pMaxWorkgroupSize = pMaxWorkgroupSize;
4234     status = UNIX_CALL(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, &params);
4235     assert(!status && "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI");
4236     return params.result;
4237 }
4238
4239 VkResult WINAPI vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
4240 {
4241     struct vkGetDynamicRenderingTilePropertiesQCOM_params params;
4242     NTSTATUS status;
4243     params.device = device;
4244     params.pRenderingInfo = pRenderingInfo;
4245     params.pProperties = pProperties;
4246     status = UNIX_CALL(vkGetDynamicRenderingTilePropertiesQCOM, &params);
4247     assert(!status && "vkGetDynamicRenderingTilePropertiesQCOM");
4248     return params.result;
4249 }
4250
4251 VkResult WINAPI vkGetEventStatus(VkDevice device, VkEvent event)
4252 {
4253     struct vkGetEventStatus_params params;
4254     NTSTATUS status;
4255     params.device = device;
4256     params.event = event;
4257     status = UNIX_CALL(vkGetEventStatus, &params);
4258     assert(!status && "vkGetEventStatus");
4259     return params.result;
4260 }
4261
4262 VkResult WINAPI vkGetFenceStatus(VkDevice device, VkFence fence)
4263 {
4264     struct vkGetFenceStatus_params params;
4265     NTSTATUS status;
4266     params.device = device;
4267     params.fence = fence;
4268     status = UNIX_CALL(vkGetFenceStatus, &params);
4269     assert(!status && "vkGetFenceStatus");
4270     return params.result;
4271 }
4272
4273 VkResult WINAPI vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
4274 {
4275     struct vkGetFramebufferTilePropertiesQCOM_params params;
4276     NTSTATUS status;
4277     params.device = device;
4278     params.framebuffer = framebuffer;
4279     params.pPropertiesCount = pPropertiesCount;
4280     params.pProperties = pProperties;
4281     status = UNIX_CALL(vkGetFramebufferTilePropertiesQCOM, &params);
4282     assert(!status && "vkGetFramebufferTilePropertiesQCOM");
4283     return params.result;
4284 }
4285
4286 void WINAPI vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
4287 {
4288     struct vkGetGeneratedCommandsMemoryRequirementsNV_params params;
4289     NTSTATUS status;
4290     params.device = device;
4291     params.pInfo = pInfo;
4292     params.pMemoryRequirements = pMemoryRequirements;
4293     status = UNIX_CALL(vkGetGeneratedCommandsMemoryRequirementsNV, &params);
4294     assert(!status && "vkGetGeneratedCommandsMemoryRequirementsNV");
4295 }
4296
4297 void WINAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
4298 {
4299     struct vkGetImageMemoryRequirements_params params;
4300     NTSTATUS status;
4301     params.device = device;
4302     params.image = image;
4303     params.pMemoryRequirements = pMemoryRequirements;
4304     status = UNIX_CALL(vkGetImageMemoryRequirements, &params);
4305     assert(!status && "vkGetImageMemoryRequirements");
4306 }
4307
4308 void WINAPI vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
4309 {
4310     struct vkGetImageMemoryRequirements2_params params;
4311     NTSTATUS status;
4312     params.device = device;
4313     params.pInfo = pInfo;
4314     params.pMemoryRequirements = pMemoryRequirements;
4315     status = UNIX_CALL(vkGetImageMemoryRequirements2, &params);
4316     assert(!status && "vkGetImageMemoryRequirements2");
4317 }
4318
4319 void WINAPI vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
4320 {
4321     struct vkGetImageMemoryRequirements2KHR_params params;
4322     NTSTATUS status;
4323     params.device = device;
4324     params.pInfo = pInfo;
4325     params.pMemoryRequirements = pMemoryRequirements;
4326     status = UNIX_CALL(vkGetImageMemoryRequirements2KHR, &params);
4327     assert(!status && "vkGetImageMemoryRequirements2KHR");
4328 }
4329
4330 VkResult WINAPI vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
4331 {
4332     struct vkGetImageOpaqueCaptureDescriptorDataEXT_params params;
4333     NTSTATUS status;
4334     params.device = device;
4335     params.pInfo = pInfo;
4336     params.pData = pData;
4337     status = UNIX_CALL(vkGetImageOpaqueCaptureDescriptorDataEXT, &params);
4338     assert(!status && "vkGetImageOpaqueCaptureDescriptorDataEXT");
4339     return params.result;
4340 }
4341
4342 void WINAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
4343 {
4344     struct vkGetImageSparseMemoryRequirements_params params;
4345     NTSTATUS status;
4346     params.device = device;
4347     params.image = image;
4348     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
4349     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
4350     status = UNIX_CALL(vkGetImageSparseMemoryRequirements, &params);
4351     assert(!status && "vkGetImageSparseMemoryRequirements");
4352 }
4353
4354 void WINAPI vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
4355 {
4356     struct vkGetImageSparseMemoryRequirements2_params params;
4357     NTSTATUS status;
4358     params.device = device;
4359     params.pInfo = pInfo;
4360     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
4361     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
4362     status = UNIX_CALL(vkGetImageSparseMemoryRequirements2, &params);
4363     assert(!status && "vkGetImageSparseMemoryRequirements2");
4364 }
4365
4366 void WINAPI vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
4367 {
4368     struct vkGetImageSparseMemoryRequirements2KHR_params params;
4369     NTSTATUS status;
4370     params.device = device;
4371     params.pInfo = pInfo;
4372     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
4373     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
4374     status = UNIX_CALL(vkGetImageSparseMemoryRequirements2KHR, &params);
4375     assert(!status && "vkGetImageSparseMemoryRequirements2KHR");
4376 }
4377
4378 void WINAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
4379 {
4380     struct vkGetImageSubresourceLayout_params params;
4381     NTSTATUS status;
4382     params.device = device;
4383     params.image = image;
4384     params.pSubresource = pSubresource;
4385     params.pLayout = pLayout;
4386     status = UNIX_CALL(vkGetImageSubresourceLayout, &params);
4387     assert(!status && "vkGetImageSubresourceLayout");
4388 }
4389
4390 void WINAPI vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2KHR *pSubresource, VkSubresourceLayout2KHR *pLayout)
4391 {
4392     struct vkGetImageSubresourceLayout2EXT_params params;
4393     NTSTATUS status;
4394     params.device = device;
4395     params.image = image;
4396     params.pSubresource = pSubresource;
4397     params.pLayout = pLayout;
4398     status = UNIX_CALL(vkGetImageSubresourceLayout2EXT, &params);
4399     assert(!status && "vkGetImageSubresourceLayout2EXT");
4400 }
4401
4402 void WINAPI vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2KHR *pSubresource, VkSubresourceLayout2KHR *pLayout)
4403 {
4404     struct vkGetImageSubresourceLayout2KHR_params params;
4405     NTSTATUS status;
4406     params.device = device;
4407     params.image = image;
4408     params.pSubresource = pSubresource;
4409     params.pLayout = pLayout;
4410     status = UNIX_CALL(vkGetImageSubresourceLayout2KHR, &params);
4411     assert(!status && "vkGetImageSubresourceLayout2KHR");
4412 }
4413
4414 VkResult WINAPI vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
4415 {
4416     struct vkGetImageViewAddressNVX_params params;
4417     NTSTATUS status;
4418     params.device = device;
4419     params.imageView = imageView;
4420     params.pProperties = pProperties;
4421     status = UNIX_CALL(vkGetImageViewAddressNVX, &params);
4422     assert(!status && "vkGetImageViewAddressNVX");
4423     return params.result;
4424 }
4425
4426 uint32_t WINAPI vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
4427 {
4428     struct vkGetImageViewHandleNVX_params params;
4429     NTSTATUS status;
4430     params.device = device;
4431     params.pInfo = pInfo;
4432     status = UNIX_CALL(vkGetImageViewHandleNVX, &params);
4433     assert(!status && "vkGetImageViewHandleNVX");
4434     return params.result;
4435 }
4436
4437 VkResult WINAPI vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
4438 {
4439     struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params params;
4440     NTSTATUS status;
4441     params.device = device;
4442     params.pInfo = pInfo;
4443     params.pData = pData;
4444     status = UNIX_CALL(vkGetImageViewOpaqueCaptureDescriptorDataEXT, &params);
4445     assert(!status && "vkGetImageViewOpaqueCaptureDescriptorDataEXT");
4446     return params.result;
4447 }
4448
4449 void WINAPI vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pTimingCount, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo)
4450 {
4451     struct vkGetLatencyTimingsNV_params params;
4452     NTSTATUS status;
4453     params.device = device;
4454     params.swapchain = swapchain;
4455     params.pTimingCount = pTimingCount;
4456     params.pLatencyMarkerInfo = pLatencyMarkerInfo;
4457     status = UNIX_CALL(vkGetLatencyTimingsNV, &params);
4458     assert(!status && "vkGetLatencyTimingsNV");
4459 }
4460
4461 VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
4462 {
4463     struct vkGetMemoryHostPointerPropertiesEXT_params params;
4464     NTSTATUS status;
4465     params.device = device;
4466     params.handleType = handleType;
4467     params.pHostPointer = pHostPointer;
4468     params.pMemoryHostPointerProperties = pMemoryHostPointerProperties;
4469     status = UNIX_CALL(vkGetMemoryHostPointerPropertiesEXT, &params);
4470     assert(!status && "vkGetMemoryHostPointerPropertiesEXT");
4471     return params.result;
4472 }
4473
4474 void WINAPI vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
4475 {
4476     struct vkGetMicromapBuildSizesEXT_params params;
4477     NTSTATUS status;
4478     params.device = device;
4479     params.buildType = buildType;
4480     params.pBuildInfo = pBuildInfo;
4481     params.pSizeInfo = pSizeInfo;
4482     status = UNIX_CALL(vkGetMicromapBuildSizesEXT, &params);
4483     assert(!status && "vkGetMicromapBuildSizesEXT");
4484 }
4485
4486 VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
4487 {
4488     struct vkGetPerformanceParameterINTEL_params params;
4489     NTSTATUS status;
4490     params.device = device;
4491     params.parameter = parameter;
4492     params.pValue = pValue;
4493     status = UNIX_CALL(vkGetPerformanceParameterINTEL, &params);
4494     assert(!status && "vkGetPerformanceParameterINTEL");
4495     return params.result;
4496 }
4497
4498 VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
4499 {
4500     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params params;
4501     NTSTATUS status;
4502     params.physicalDevice = physicalDevice;
4503     params.pTimeDomainCount = pTimeDomainCount;
4504     params.pTimeDomains = pTimeDomains;
4505     status = UNIX_CALL(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, &params);
4506     assert(!status && "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT");
4507     return params.result;
4508 }
4509
4510 VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties)
4511 {
4512     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params params;
4513     NTSTATUS status;
4514     params.physicalDevice = physicalDevice;
4515     params.pPropertyCount = pPropertyCount;
4516     params.pProperties = pProperties;
4517     status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, &params);
4518     assert(!status && "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR");
4519     return params.result;
4520 }
4521
4522 VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
4523 {
4524     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params params;
4525     NTSTATUS status;
4526     params.physicalDevice = physicalDevice;
4527     params.pPropertyCount = pPropertyCount;
4528     params.pProperties = pProperties;
4529     status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, &params);
4530     assert(!status && "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV");
4531     return params.result;
4532 }
4533
4534 void WINAPI vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
4535 {
4536     struct vkGetPhysicalDeviceExternalBufferProperties_params params;
4537     NTSTATUS status;
4538     params.physicalDevice = physicalDevice;
4539     params.pExternalBufferInfo = pExternalBufferInfo;
4540     params.pExternalBufferProperties = pExternalBufferProperties;
4541     status = UNIX_CALL(vkGetPhysicalDeviceExternalBufferProperties, &params);
4542     assert(!status && "vkGetPhysicalDeviceExternalBufferProperties");
4543 }
4544
4545 void WINAPI vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
4546 {
4547     struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params params;
4548     NTSTATUS status;
4549     params.physicalDevice = physicalDevice;
4550     params.pExternalBufferInfo = pExternalBufferInfo;
4551     params.pExternalBufferProperties = pExternalBufferProperties;
4552     status = UNIX_CALL(vkGetPhysicalDeviceExternalBufferPropertiesKHR, &params);
4553     assert(!status && "vkGetPhysicalDeviceExternalBufferPropertiesKHR");
4554 }
4555
4556 void WINAPI vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
4557 {
4558     struct vkGetPhysicalDeviceExternalFenceProperties_params params;
4559     NTSTATUS status;
4560     params.physicalDevice = physicalDevice;
4561     params.pExternalFenceInfo = pExternalFenceInfo;
4562     params.pExternalFenceProperties = pExternalFenceProperties;
4563     status = UNIX_CALL(vkGetPhysicalDeviceExternalFenceProperties, &params);
4564     assert(!status && "vkGetPhysicalDeviceExternalFenceProperties");
4565 }
4566
4567 void WINAPI vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
4568 {
4569     struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params params;
4570     NTSTATUS status;
4571     params.physicalDevice = physicalDevice;
4572     params.pExternalFenceInfo = pExternalFenceInfo;
4573     params.pExternalFenceProperties = pExternalFenceProperties;
4574     status = UNIX_CALL(vkGetPhysicalDeviceExternalFencePropertiesKHR, &params);
4575     assert(!status && "vkGetPhysicalDeviceExternalFencePropertiesKHR");
4576 }
4577
4578 void WINAPI vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
4579 {
4580     struct vkGetPhysicalDeviceExternalSemaphoreProperties_params params;
4581     NTSTATUS status;
4582     params.physicalDevice = physicalDevice;
4583     params.pExternalSemaphoreInfo = pExternalSemaphoreInfo;
4584     params.pExternalSemaphoreProperties = pExternalSemaphoreProperties;
4585     status = UNIX_CALL(vkGetPhysicalDeviceExternalSemaphoreProperties, &params);
4586     assert(!status && "vkGetPhysicalDeviceExternalSemaphoreProperties");
4587 }
4588
4589 void WINAPI vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
4590 {
4591     struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params params;
4592     NTSTATUS status;
4593     params.physicalDevice = physicalDevice;
4594     params.pExternalSemaphoreInfo = pExternalSemaphoreInfo;
4595     params.pExternalSemaphoreProperties = pExternalSemaphoreProperties;
4596     status = UNIX_CALL(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, &params);
4597     assert(!status && "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
4598 }
4599
4600 void WINAPI vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
4601 {
4602     struct vkGetPhysicalDeviceFeatures_params params;
4603     NTSTATUS status;
4604     params.physicalDevice = physicalDevice;
4605     params.pFeatures = pFeatures;
4606     status = UNIX_CALL(vkGetPhysicalDeviceFeatures, &params);
4607     assert(!status && "vkGetPhysicalDeviceFeatures");
4608 }
4609
4610 void WINAPI vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
4611 {
4612     struct vkGetPhysicalDeviceFeatures2_params params;
4613     NTSTATUS status;
4614     params.physicalDevice = physicalDevice;
4615     params.pFeatures = pFeatures;
4616     status = UNIX_CALL(vkGetPhysicalDeviceFeatures2, &params);
4617     assert(!status && "vkGetPhysicalDeviceFeatures2");
4618 }
4619
4620 void WINAPI vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
4621 {
4622     struct vkGetPhysicalDeviceFeatures2KHR_params params;
4623     NTSTATUS status;
4624     params.physicalDevice = physicalDevice;
4625     params.pFeatures = pFeatures;
4626     status = UNIX_CALL(vkGetPhysicalDeviceFeatures2KHR, &params);
4627     assert(!status && "vkGetPhysicalDeviceFeatures2KHR");
4628 }
4629
4630 void WINAPI vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
4631 {
4632     struct vkGetPhysicalDeviceFormatProperties_params params;
4633     NTSTATUS status;
4634     params.physicalDevice = physicalDevice;
4635     params.format = format;
4636     params.pFormatProperties = pFormatProperties;
4637     status = UNIX_CALL(vkGetPhysicalDeviceFormatProperties, &params);
4638     assert(!status && "vkGetPhysicalDeviceFormatProperties");
4639 }
4640
4641 void WINAPI vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
4642 {
4643     struct vkGetPhysicalDeviceFormatProperties2_params params;
4644     NTSTATUS status;
4645     params.physicalDevice = physicalDevice;
4646     params.format = format;
4647     params.pFormatProperties = pFormatProperties;
4648     status = UNIX_CALL(vkGetPhysicalDeviceFormatProperties2, &params);
4649     assert(!status && "vkGetPhysicalDeviceFormatProperties2");
4650 }
4651
4652 void WINAPI vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
4653 {
4654     struct vkGetPhysicalDeviceFormatProperties2KHR_params params;
4655     NTSTATUS status;
4656     params.physicalDevice = physicalDevice;
4657     params.format = format;
4658     params.pFormatProperties = pFormatProperties;
4659     status = UNIX_CALL(vkGetPhysicalDeviceFormatProperties2KHR, &params);
4660     assert(!status && "vkGetPhysicalDeviceFormatProperties2KHR");
4661 }
4662
4663 VkResult WINAPI vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
4664 {
4665     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params params;
4666     NTSTATUS status;
4667     params.physicalDevice = physicalDevice;
4668     params.pFragmentShadingRateCount = pFragmentShadingRateCount;
4669     params.pFragmentShadingRates = pFragmentShadingRates;
4670     status = UNIX_CALL(vkGetPhysicalDeviceFragmentShadingRatesKHR, &params);
4671     assert(!status && "vkGetPhysicalDeviceFragmentShadingRatesKHR");
4672     return params.result;
4673 }
4674
4675 VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
4676 {
4677     struct vkGetPhysicalDeviceImageFormatProperties_params params;
4678     NTSTATUS status;
4679     params.physicalDevice = physicalDevice;
4680     params.format = format;
4681     params.type = type;
4682     params.tiling = tiling;
4683     params.usage = usage;
4684     params.flags = flags;
4685     params.pImageFormatProperties = pImageFormatProperties;
4686     status = UNIX_CALL(vkGetPhysicalDeviceImageFormatProperties, &params);
4687     assert(!status && "vkGetPhysicalDeviceImageFormatProperties");
4688     return params.result;
4689 }
4690
4691 VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
4692 {
4693     struct vkGetPhysicalDeviceImageFormatProperties2_params params;
4694     NTSTATUS status;
4695     params.physicalDevice = physicalDevice;
4696     params.pImageFormatInfo = pImageFormatInfo;
4697     params.pImageFormatProperties = pImageFormatProperties;
4698     status = UNIX_CALL(vkGetPhysicalDeviceImageFormatProperties2, &params);
4699     assert(!status && "vkGetPhysicalDeviceImageFormatProperties2");
4700     return params.result;
4701 }
4702
4703 VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
4704 {
4705     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params params;
4706     NTSTATUS status;
4707     params.physicalDevice = physicalDevice;
4708     params.pImageFormatInfo = pImageFormatInfo;
4709     params.pImageFormatProperties = pImageFormatProperties;
4710     status = UNIX_CALL(vkGetPhysicalDeviceImageFormatProperties2KHR, &params);
4711     assert(!status && "vkGetPhysicalDeviceImageFormatProperties2KHR");
4712     return params.result;
4713 }
4714
4715 void WINAPI vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
4716 {
4717     struct vkGetPhysicalDeviceMemoryProperties_params params;
4718     NTSTATUS status;
4719     params.physicalDevice = physicalDevice;
4720     params.pMemoryProperties = pMemoryProperties;
4721     status = UNIX_CALL(vkGetPhysicalDeviceMemoryProperties, &params);
4722     assert(!status && "vkGetPhysicalDeviceMemoryProperties");
4723 }
4724
4725 void WINAPI vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
4726 {
4727     struct vkGetPhysicalDeviceMemoryProperties2_params params;
4728     NTSTATUS status;
4729     params.physicalDevice = physicalDevice;
4730     params.pMemoryProperties = pMemoryProperties;
4731     status = UNIX_CALL(vkGetPhysicalDeviceMemoryProperties2, &params);
4732     assert(!status && "vkGetPhysicalDeviceMemoryProperties2");
4733 }
4734
4735 void WINAPI vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
4736 {
4737     struct vkGetPhysicalDeviceMemoryProperties2KHR_params params;
4738     NTSTATUS status;
4739     params.physicalDevice = physicalDevice;
4740     params.pMemoryProperties = pMemoryProperties;
4741     status = UNIX_CALL(vkGetPhysicalDeviceMemoryProperties2KHR, &params);
4742     assert(!status && "vkGetPhysicalDeviceMemoryProperties2KHR");
4743 }
4744
4745 void WINAPI vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
4746 {
4747     struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params params;
4748     NTSTATUS status;
4749     params.physicalDevice = physicalDevice;
4750     params.samples = samples;
4751     params.pMultisampleProperties = pMultisampleProperties;
4752     status = UNIX_CALL(vkGetPhysicalDeviceMultisamplePropertiesEXT, &params);
4753     assert(!status && "vkGetPhysicalDeviceMultisamplePropertiesEXT");
4754 }
4755
4756 VkResult WINAPI vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
4757 {
4758     struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params params;
4759     NTSTATUS status;
4760     params.physicalDevice = physicalDevice;
4761     params.pOpticalFlowImageFormatInfo = pOpticalFlowImageFormatInfo;
4762     params.pFormatCount = pFormatCount;
4763     params.pImageFormatProperties = pImageFormatProperties;
4764     status = UNIX_CALL(vkGetPhysicalDeviceOpticalFlowImageFormatsNV, &params);
4765     assert(!status && "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
4766     return params.result;
4767 }
4768
4769 VkResult WINAPI vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
4770 {
4771     struct vkGetPhysicalDevicePresentRectanglesKHR_params params;
4772     NTSTATUS status;
4773     params.physicalDevice = physicalDevice;
4774     params.surface = surface;
4775     params.pRectCount = pRectCount;
4776     params.pRects = pRects;
4777     status = UNIX_CALL(vkGetPhysicalDevicePresentRectanglesKHR, &params);
4778     assert(!status && "vkGetPhysicalDevicePresentRectanglesKHR");
4779     return params.result;
4780 }
4781
4782 void WINAPI vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
4783 {
4784     struct vkGetPhysicalDeviceProperties_params params;
4785     NTSTATUS status;
4786     params.physicalDevice = physicalDevice;
4787     params.pProperties = pProperties;
4788     status = UNIX_CALL(vkGetPhysicalDeviceProperties, &params);
4789     assert(!status && "vkGetPhysicalDeviceProperties");
4790 }
4791
4792 void WINAPI vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
4793 {
4794     struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params params;
4795     NTSTATUS status;
4796     params.physicalDevice = physicalDevice;
4797     params.pPerformanceQueryCreateInfo = pPerformanceQueryCreateInfo;
4798     params.pNumPasses = pNumPasses;
4799     status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, &params);
4800     assert(!status && "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
4801 }
4802
4803 void WINAPI vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
4804 {
4805     struct vkGetPhysicalDeviceQueueFamilyProperties_params params;
4806     NTSTATUS status;
4807     params.physicalDevice = physicalDevice;
4808     params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount;
4809     params.pQueueFamilyProperties = pQueueFamilyProperties;
4810     status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyProperties, &params);
4811     assert(!status && "vkGetPhysicalDeviceQueueFamilyProperties");
4812 }
4813
4814 void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
4815 {
4816     struct vkGetPhysicalDeviceQueueFamilyProperties2_params params;
4817     NTSTATUS status;
4818     params.physicalDevice = physicalDevice;
4819     params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount;
4820     params.pQueueFamilyProperties = pQueueFamilyProperties;
4821     status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyProperties2, &params);
4822     assert(!status && "vkGetPhysicalDeviceQueueFamilyProperties2");
4823 }
4824
4825 void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
4826 {
4827     struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params params;
4828     NTSTATUS status;
4829     params.physicalDevice = physicalDevice;
4830     params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount;
4831     params.pQueueFamilyProperties = pQueueFamilyProperties;
4832     status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyProperties2KHR, &params);
4833     assert(!status && "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
4834 }
4835
4836 void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
4837 {
4838     struct vkGetPhysicalDeviceSparseImageFormatProperties_params params;
4839     NTSTATUS status;
4840     params.physicalDevice = physicalDevice;
4841     params.format = format;
4842     params.type = type;
4843     params.samples = samples;
4844     params.usage = usage;
4845     params.tiling = tiling;
4846     params.pPropertyCount = pPropertyCount;
4847     params.pProperties = pProperties;
4848     status = UNIX_CALL(vkGetPhysicalDeviceSparseImageFormatProperties, &params);
4849     assert(!status && "vkGetPhysicalDeviceSparseImageFormatProperties");
4850 }
4851
4852 void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
4853 {
4854     struct vkGetPhysicalDeviceSparseImageFormatProperties2_params params;
4855     NTSTATUS status;
4856     params.physicalDevice = physicalDevice;
4857     params.pFormatInfo = pFormatInfo;
4858     params.pPropertyCount = pPropertyCount;
4859     params.pProperties = pProperties;
4860     status = UNIX_CALL(vkGetPhysicalDeviceSparseImageFormatProperties2, &params);
4861     assert(!status && "vkGetPhysicalDeviceSparseImageFormatProperties2");
4862 }
4863
4864 void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
4865 {
4866     struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params params;
4867     NTSTATUS status;
4868     params.physicalDevice = physicalDevice;
4869     params.pFormatInfo = pFormatInfo;
4870     params.pPropertyCount = pPropertyCount;
4871     params.pProperties = pProperties;
4872     status = UNIX_CALL(vkGetPhysicalDeviceSparseImageFormatProperties2KHR, &params);
4873     assert(!status && "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
4874 }
4875
4876 VkResult WINAPI vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
4877 {
4878     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params params;
4879     NTSTATUS status;
4880     params.physicalDevice = physicalDevice;
4881     params.pCombinationCount = pCombinationCount;
4882     params.pCombinations = pCombinations;
4883     status = UNIX_CALL(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, &params);
4884     assert(!status && "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV");
4885     return params.result;
4886 }
4887
4888 VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
4889 {
4890     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params params;
4891     NTSTATUS status;
4892     params.physicalDevice = physicalDevice;
4893     params.pSurfaceInfo = pSurfaceInfo;
4894     params.pSurfaceCapabilities = pSurfaceCapabilities;
4895     status = UNIX_CALL(vkGetPhysicalDeviceSurfaceCapabilities2KHR, &params);
4896     assert(!status && "vkGetPhysicalDeviceSurfaceCapabilities2KHR");
4897     return params.result;
4898 }
4899
4900 VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
4901 {
4902     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params params;
4903     NTSTATUS status;
4904     params.physicalDevice = physicalDevice;
4905     params.surface = surface;
4906     params.pSurfaceCapabilities = pSurfaceCapabilities;
4907     status = UNIX_CALL(vkGetPhysicalDeviceSurfaceCapabilitiesKHR, &params);
4908     assert(!status && "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
4909     return params.result;
4910 }
4911
4912 VkResult WINAPI vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
4913 {
4914     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params params;
4915     NTSTATUS status;
4916     params.physicalDevice = physicalDevice;
4917     params.pSurfaceInfo = pSurfaceInfo;
4918     params.pSurfaceFormatCount = pSurfaceFormatCount;
4919     params.pSurfaceFormats = pSurfaceFormats;
4920     status = UNIX_CALL(vkGetPhysicalDeviceSurfaceFormats2KHR, &params);
4921     assert(!status && "vkGetPhysicalDeviceSurfaceFormats2KHR");
4922     return params.result;
4923 }
4924
4925 VkResult WINAPI vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
4926 {
4927     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params params;
4928     NTSTATUS status;
4929     params.physicalDevice = physicalDevice;
4930     params.surface = surface;
4931     params.pSurfaceFormatCount = pSurfaceFormatCount;
4932     params.pSurfaceFormats = pSurfaceFormats;
4933     status = UNIX_CALL(vkGetPhysicalDeviceSurfaceFormatsKHR, &params);
4934     assert(!status && "vkGetPhysicalDeviceSurfaceFormatsKHR");
4935     return params.result;
4936 }
4937
4938 VkResult WINAPI vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
4939 {
4940     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params params;
4941     NTSTATUS status;
4942     params.physicalDevice = physicalDevice;
4943     params.surface = surface;
4944     params.pPresentModeCount = pPresentModeCount;
4945     params.pPresentModes = pPresentModes;
4946     status = UNIX_CALL(vkGetPhysicalDeviceSurfacePresentModesKHR, &params);
4947     assert(!status && "vkGetPhysicalDeviceSurfacePresentModesKHR");
4948     return params.result;
4949 }
4950
4951 VkResult WINAPI vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
4952 {
4953     struct vkGetPhysicalDeviceSurfaceSupportKHR_params params;
4954     NTSTATUS status;
4955     params.physicalDevice = physicalDevice;
4956     params.queueFamilyIndex = queueFamilyIndex;
4957     params.surface = surface;
4958     params.pSupported = pSupported;
4959     status = UNIX_CALL(vkGetPhysicalDeviceSurfaceSupportKHR, &params);
4960     assert(!status && "vkGetPhysicalDeviceSurfaceSupportKHR");
4961     return params.result;
4962 }
4963
4964 VkResult WINAPI vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
4965 {
4966     struct vkGetPhysicalDeviceToolProperties_params params;
4967     NTSTATUS status;
4968     params.physicalDevice = physicalDevice;
4969     params.pToolCount = pToolCount;
4970     params.pToolProperties = pToolProperties;
4971     status = UNIX_CALL(vkGetPhysicalDeviceToolProperties, &params);
4972     assert(!status && "vkGetPhysicalDeviceToolProperties");
4973     return params.result;
4974 }
4975
4976 VkResult WINAPI vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
4977 {
4978     struct vkGetPhysicalDeviceToolPropertiesEXT_params params;
4979     NTSTATUS status;
4980     params.physicalDevice = physicalDevice;
4981     params.pToolCount = pToolCount;
4982     params.pToolProperties = pToolProperties;
4983     status = UNIX_CALL(vkGetPhysicalDeviceToolPropertiesEXT, &params);
4984     assert(!status && "vkGetPhysicalDeviceToolPropertiesEXT");
4985     return params.result;
4986 }
4987
4988 VkBool32 WINAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
4989 {
4990     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params params;
4991     NTSTATUS status;
4992     params.physicalDevice = physicalDevice;
4993     params.queueFamilyIndex = queueFamilyIndex;
4994     status = UNIX_CALL(vkGetPhysicalDeviceWin32PresentationSupportKHR, &params);
4995     assert(!status && "vkGetPhysicalDeviceWin32PresentationSupportKHR");
4996     return params.result;
4997 }
4998
4999 VkResult WINAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
5000 {
5001     struct vkGetPipelineCacheData_params params;
5002     NTSTATUS status;
5003     params.device = device;
5004     params.pipelineCache = pipelineCache;
5005     params.pDataSize = pDataSize;
5006     params.pData = pData;
5007     status = UNIX_CALL(vkGetPipelineCacheData, &params);
5008     assert(!status && "vkGetPipelineCacheData");
5009     return params.result;
5010 }
5011
5012 VkResult WINAPI vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
5013 {
5014     struct vkGetPipelineExecutableInternalRepresentationsKHR_params params;
5015     NTSTATUS status;
5016     params.device = device;
5017     params.pExecutableInfo = pExecutableInfo;
5018     params.pInternalRepresentationCount = pInternalRepresentationCount;
5019     params.pInternalRepresentations = pInternalRepresentations;
5020     status = UNIX_CALL(vkGetPipelineExecutableInternalRepresentationsKHR, &params);
5021     assert(!status && "vkGetPipelineExecutableInternalRepresentationsKHR");
5022     return params.result;
5023 }
5024
5025 VkResult WINAPI vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
5026 {
5027     struct vkGetPipelineExecutablePropertiesKHR_params params;
5028     NTSTATUS status;
5029     params.device = device;
5030     params.pPipelineInfo = pPipelineInfo;
5031     params.pExecutableCount = pExecutableCount;
5032     params.pProperties = pProperties;
5033     status = UNIX_CALL(vkGetPipelineExecutablePropertiesKHR, &params);
5034     assert(!status && "vkGetPipelineExecutablePropertiesKHR");
5035     return params.result;
5036 }
5037
5038 VkResult WINAPI vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
5039 {
5040     struct vkGetPipelineExecutableStatisticsKHR_params params;
5041     NTSTATUS status;
5042     params.device = device;
5043     params.pExecutableInfo = pExecutableInfo;
5044     params.pStatisticCount = pStatisticCount;
5045     params.pStatistics = pStatistics;
5046     status = UNIX_CALL(vkGetPipelineExecutableStatisticsKHR, &params);
5047     assert(!status && "vkGetPipelineExecutableStatisticsKHR");
5048     return params.result;
5049 }
5050
5051 VkDeviceAddress WINAPI vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV *pInfo)
5052 {
5053     struct vkGetPipelineIndirectDeviceAddressNV_params params;
5054     NTSTATUS status;
5055     params.device = device;
5056     params.pInfo = pInfo;
5057     status = UNIX_CALL(vkGetPipelineIndirectDeviceAddressNV, &params);
5058     assert(!status && "vkGetPipelineIndirectDeviceAddressNV");
5059     return params.result;
5060 }
5061
5062 void WINAPI vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo *pCreateInfo, VkMemoryRequirements2 *pMemoryRequirements)
5063 {
5064     struct vkGetPipelineIndirectMemoryRequirementsNV_params params;
5065     NTSTATUS status;
5066     params.device = device;
5067     params.pCreateInfo = pCreateInfo;
5068     params.pMemoryRequirements = pMemoryRequirements;
5069     status = UNIX_CALL(vkGetPipelineIndirectMemoryRequirementsNV, &params);
5070     assert(!status && "vkGetPipelineIndirectMemoryRequirementsNV");
5071 }
5072
5073 VkResult WINAPI vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
5074 {
5075     struct vkGetPipelinePropertiesEXT_params params;
5076     NTSTATUS status;
5077     params.device = device;
5078     params.pPipelineInfo = pPipelineInfo;
5079     params.pPipelineProperties = pPipelineProperties;
5080     status = UNIX_CALL(vkGetPipelinePropertiesEXT, &params);
5081     assert(!status && "vkGetPipelinePropertiesEXT");
5082     return params.result;
5083 }
5084
5085 void WINAPI vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
5086 {
5087     struct vkGetPrivateData_params params;
5088     NTSTATUS status;
5089     params.device = device;
5090     params.objectType = objectType;
5091     params.objectHandle = objectHandle;
5092     params.privateDataSlot = privateDataSlot;
5093     params.pData = pData;
5094     status = UNIX_CALL(vkGetPrivateData, &params);
5095     assert(!status && "vkGetPrivateData");
5096 }
5097
5098 void WINAPI vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
5099 {
5100     struct vkGetPrivateDataEXT_params params;
5101     NTSTATUS status;
5102     params.device = device;
5103     params.objectType = objectType;
5104     params.objectHandle = objectHandle;
5105     params.privateDataSlot = privateDataSlot;
5106     params.pData = pData;
5107     status = UNIX_CALL(vkGetPrivateDataEXT, &params);
5108     assert(!status && "vkGetPrivateDataEXT");
5109 }
5110
5111 VkResult WINAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
5112 {
5113     struct vkGetQueryPoolResults_params params;
5114     NTSTATUS status;
5115     params.device = device;
5116     params.queryPool = queryPool;
5117     params.firstQuery = firstQuery;
5118     params.queryCount = queryCount;
5119     params.dataSize = dataSize;
5120     params.pData = pData;
5121     params.stride = stride;
5122     params.flags = flags;
5123     status = UNIX_CALL(vkGetQueryPoolResults, &params);
5124     assert(!status && "vkGetQueryPoolResults");
5125     return params.result;
5126 }
5127
5128 void WINAPI vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
5129 {
5130     struct vkGetQueueCheckpointData2NV_params params;
5131     NTSTATUS status;
5132     params.queue = queue;
5133     params.pCheckpointDataCount = pCheckpointDataCount;
5134     params.pCheckpointData = pCheckpointData;
5135     status = UNIX_CALL(vkGetQueueCheckpointData2NV, &params);
5136     assert(!status && "vkGetQueueCheckpointData2NV");
5137 }
5138
5139 void WINAPI vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
5140 {
5141     struct vkGetQueueCheckpointDataNV_params params;
5142     NTSTATUS status;
5143     params.queue = queue;
5144     params.pCheckpointDataCount = pCheckpointDataCount;
5145     params.pCheckpointData = pCheckpointData;
5146     status = UNIX_CALL(vkGetQueueCheckpointDataNV, &params);
5147     assert(!status && "vkGetQueueCheckpointDataNV");
5148 }
5149
5150 VkResult WINAPI vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
5151 {
5152     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params params;
5153     NTSTATUS status;
5154     params.device = device;
5155     params.pipeline = pipeline;
5156     params.firstGroup = firstGroup;
5157     params.groupCount = groupCount;
5158     params.dataSize = dataSize;
5159     params.pData = pData;
5160     status = UNIX_CALL(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, &params);
5161     assert(!status && "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
5162     return params.result;
5163 }
5164
5165 VkResult WINAPI vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
5166 {
5167     struct vkGetRayTracingShaderGroupHandlesKHR_params params;
5168     NTSTATUS status;
5169     params.device = device;
5170     params.pipeline = pipeline;
5171     params.firstGroup = firstGroup;
5172     params.groupCount = groupCount;
5173     params.dataSize = dataSize;
5174     params.pData = pData;
5175     status = UNIX_CALL(vkGetRayTracingShaderGroupHandlesKHR, &params);
5176     assert(!status && "vkGetRayTracingShaderGroupHandlesKHR");
5177     return params.result;
5178 }
5179
5180 VkResult WINAPI vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
5181 {
5182     struct vkGetRayTracingShaderGroupHandlesNV_params params;
5183     NTSTATUS status;
5184     params.device = device;
5185     params.pipeline = pipeline;
5186     params.firstGroup = firstGroup;
5187     params.groupCount = groupCount;
5188     params.dataSize = dataSize;
5189     params.pData = pData;
5190     status = UNIX_CALL(vkGetRayTracingShaderGroupHandlesNV, &params);
5191     assert(!status && "vkGetRayTracingShaderGroupHandlesNV");
5192     return params.result;
5193 }
5194
5195 VkDeviceSize WINAPI vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
5196 {
5197     struct vkGetRayTracingShaderGroupStackSizeKHR_params params;
5198     NTSTATUS status;
5199     params.device = device;
5200     params.pipeline = pipeline;
5201     params.group = group;
5202     params.groupShader = groupShader;
5203     status = UNIX_CALL(vkGetRayTracingShaderGroupStackSizeKHR, &params);
5204     assert(!status && "vkGetRayTracingShaderGroupStackSizeKHR");
5205     return params.result;
5206 }
5207
5208 void WINAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
5209 {
5210     struct vkGetRenderAreaGranularity_params params;
5211     NTSTATUS status;
5212     params.device = device;
5213     params.renderPass = renderPass;
5214     params.pGranularity = pGranularity;
5215     status = UNIX_CALL(vkGetRenderAreaGranularity, &params);
5216     assert(!status && "vkGetRenderAreaGranularity");
5217 }
5218
5219 void WINAPI vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfoKHR *pRenderingAreaInfo, VkExtent2D *pGranularity)
5220 {
5221     struct vkGetRenderingAreaGranularityKHR_params params;
5222     NTSTATUS status;
5223     params.device = device;
5224     params.pRenderingAreaInfo = pRenderingAreaInfo;
5225     params.pGranularity = pGranularity;
5226     status = UNIX_CALL(vkGetRenderingAreaGranularityKHR, &params);
5227     assert(!status && "vkGetRenderingAreaGranularityKHR");
5228 }
5229
5230 VkResult WINAPI vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
5231 {
5232     struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params params;
5233     NTSTATUS status;
5234     params.device = device;
5235     params.pInfo = pInfo;
5236     params.pData = pData;
5237     status = UNIX_CALL(vkGetSamplerOpaqueCaptureDescriptorDataEXT, &params);
5238     assert(!status && "vkGetSamplerOpaqueCaptureDescriptorDataEXT");
5239     return params.result;
5240 }
5241
5242 VkResult WINAPI vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
5243 {
5244     struct vkGetSemaphoreCounterValue_params params;
5245     NTSTATUS status;
5246     params.device = device;
5247     params.semaphore = semaphore;
5248     params.pValue = pValue;
5249     status = UNIX_CALL(vkGetSemaphoreCounterValue, &params);
5250     assert(!status && "vkGetSemaphoreCounterValue");
5251     return params.result;
5252 }
5253
5254 VkResult WINAPI vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
5255 {
5256     struct vkGetSemaphoreCounterValueKHR_params params;
5257     NTSTATUS status;
5258     params.device = device;
5259     params.semaphore = semaphore;
5260     params.pValue = pValue;
5261     status = UNIX_CALL(vkGetSemaphoreCounterValueKHR, &params);
5262     assert(!status && "vkGetSemaphoreCounterValueKHR");
5263     return params.result;
5264 }
5265
5266 VkResult WINAPI vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t *pDataSize, void *pData)
5267 {
5268     struct vkGetShaderBinaryDataEXT_params params;
5269     NTSTATUS status;
5270     params.device = device;
5271     params.shader = shader;
5272     params.pDataSize = pDataSize;
5273     params.pData = pData;
5274     status = UNIX_CALL(vkGetShaderBinaryDataEXT, &params);
5275     assert(!status && "vkGetShaderBinaryDataEXT");
5276     return params.result;
5277 }
5278
5279 VkResult WINAPI vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
5280 {
5281     struct vkGetShaderInfoAMD_params params;
5282     NTSTATUS status;
5283     params.device = device;
5284     params.pipeline = pipeline;
5285     params.shaderStage = shaderStage;
5286     params.infoType = infoType;
5287     params.pInfoSize = pInfoSize;
5288     params.pInfo = pInfo;
5289     status = UNIX_CALL(vkGetShaderInfoAMD, &params);
5290     assert(!status && "vkGetShaderInfoAMD");
5291     return params.result;
5292 }
5293
5294 void WINAPI vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
5295 {
5296     struct vkGetShaderModuleCreateInfoIdentifierEXT_params params;
5297     NTSTATUS status;
5298     params.device = device;
5299     params.pCreateInfo = pCreateInfo;
5300     params.pIdentifier = pIdentifier;
5301     status = UNIX_CALL(vkGetShaderModuleCreateInfoIdentifierEXT, &params);
5302     assert(!status && "vkGetShaderModuleCreateInfoIdentifierEXT");
5303 }
5304
5305 void WINAPI vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
5306 {
5307     struct vkGetShaderModuleIdentifierEXT_params params;
5308     NTSTATUS status;
5309     params.device = device;
5310     params.shaderModule = shaderModule;
5311     params.pIdentifier = pIdentifier;
5312     status = UNIX_CALL(vkGetShaderModuleIdentifierEXT, &params);
5313     assert(!status && "vkGetShaderModuleIdentifierEXT");
5314 }
5315
5316 VkResult WINAPI vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
5317 {
5318     struct vkGetSwapchainImagesKHR_params params;
5319     NTSTATUS status;
5320     params.device = device;
5321     params.swapchain = swapchain;
5322     params.pSwapchainImageCount = pSwapchainImageCount;
5323     params.pSwapchainImages = pSwapchainImages;
5324     status = UNIX_CALL(vkGetSwapchainImagesKHR, &params);
5325     assert(!status && "vkGetSwapchainImagesKHR");
5326     return params.result;
5327 }
5328
5329 VkResult WINAPI vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
5330 {
5331     struct vkGetValidationCacheDataEXT_params params;
5332     NTSTATUS status;
5333     params.device = device;
5334     params.validationCache = validationCache;
5335     params.pDataSize = pDataSize;
5336     params.pData = pData;
5337     status = UNIX_CALL(vkGetValidationCacheDataEXT, &params);
5338     assert(!status && "vkGetValidationCacheDataEXT");
5339     return params.result;
5340 }
5341
5342 VkResult WINAPI vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
5343 {
5344     struct vkInitializePerformanceApiINTEL_params params;
5345     NTSTATUS status;
5346     params.device = device;
5347     params.pInitializeInfo = pInitializeInfo;
5348     status = UNIX_CALL(vkInitializePerformanceApiINTEL, &params);
5349     assert(!status && "vkInitializePerformanceApiINTEL");
5350     return params.result;
5351 }
5352
5353 VkResult WINAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
5354 {
5355     struct vkInvalidateMappedMemoryRanges_params params;
5356     NTSTATUS status;
5357     params.device = device;
5358     params.memoryRangeCount = memoryRangeCount;
5359     params.pMemoryRanges = pMemoryRanges;
5360     status = UNIX_CALL(vkInvalidateMappedMemoryRanges, &params);
5361     assert(!status && "vkInvalidateMappedMemoryRanges");
5362     return params.result;
5363 }
5364
5365 VkResult WINAPI vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV *pSleepInfo)
5366 {
5367     struct vkLatencySleepNV_params params;
5368     NTSTATUS status;
5369     params.device = device;
5370     params.swapchain = swapchain;
5371     params.pSleepInfo = pSleepInfo;
5372     status = UNIX_CALL(vkLatencySleepNV, &params);
5373     assert(!status && "vkLatencySleepNV");
5374     return params.result;
5375 }
5376
5377 VkResult WINAPI vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
5378 {
5379     struct vkMapMemory_params params;
5380     NTSTATUS status;
5381     params.device = device;
5382     params.memory = memory;
5383     params.offset = offset;
5384     params.size = size;
5385     params.flags = flags;
5386     params.ppData = ppData;
5387     status = UNIX_CALL(vkMapMemory, &params);
5388     assert(!status && "vkMapMemory");
5389     return params.result;
5390 }
5391
5392 VkResult WINAPI vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR *pMemoryMapInfo, void **ppData)
5393 {
5394     struct vkMapMemory2KHR_params params;
5395     NTSTATUS status;
5396     params.device = device;
5397     params.pMemoryMapInfo = pMemoryMapInfo;
5398     params.ppData = ppData;
5399     status = UNIX_CALL(vkMapMemory2KHR, &params);
5400     assert(!status && "vkMapMemory2KHR");
5401     return params.result;
5402 }
5403
5404 VkResult WINAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
5405 {
5406     struct vkMergePipelineCaches_params params;
5407     NTSTATUS status;
5408     params.device = device;
5409     params.dstCache = dstCache;
5410     params.srcCacheCount = srcCacheCount;
5411     params.pSrcCaches = pSrcCaches;
5412     status = UNIX_CALL(vkMergePipelineCaches, &params);
5413     assert(!status && "vkMergePipelineCaches");
5414     return params.result;
5415 }
5416
5417 VkResult WINAPI vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
5418 {
5419     struct vkMergeValidationCachesEXT_params params;
5420     NTSTATUS status;
5421     params.device = device;
5422     params.dstCache = dstCache;
5423     params.srcCacheCount = srcCacheCount;
5424     params.pSrcCaches = pSrcCaches;
5425     status = UNIX_CALL(vkMergeValidationCachesEXT, &params);
5426     assert(!status && "vkMergeValidationCachesEXT");
5427     return params.result;
5428 }
5429
5430 void WINAPI vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
5431 {
5432     struct vkQueueBeginDebugUtilsLabelEXT_params params;
5433     NTSTATUS status;
5434     params.queue = queue;
5435     params.pLabelInfo = pLabelInfo;
5436     status = UNIX_CALL(vkQueueBeginDebugUtilsLabelEXT, &params);
5437     assert(!status && "vkQueueBeginDebugUtilsLabelEXT");
5438 }
5439
5440 VkResult WINAPI vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
5441 {
5442     struct vkQueueBindSparse_params params;
5443     NTSTATUS status;
5444     params.queue = queue;
5445     params.bindInfoCount = bindInfoCount;
5446     params.pBindInfo = pBindInfo;
5447     params.fence = fence;
5448     status = UNIX_CALL(vkQueueBindSparse, &params);
5449     assert(!status && "vkQueueBindSparse");
5450     return params.result;
5451 }
5452
5453 void WINAPI vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
5454 {
5455     struct vkQueueEndDebugUtilsLabelEXT_params params;
5456     NTSTATUS status;
5457     params.queue = queue;
5458     status = UNIX_CALL(vkQueueEndDebugUtilsLabelEXT, &params);
5459     assert(!status && "vkQueueEndDebugUtilsLabelEXT");
5460 }
5461
5462 void WINAPI vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
5463 {
5464     struct vkQueueInsertDebugUtilsLabelEXT_params params;
5465     NTSTATUS status;
5466     params.queue = queue;
5467     params.pLabelInfo = pLabelInfo;
5468     status = UNIX_CALL(vkQueueInsertDebugUtilsLabelEXT, &params);
5469     assert(!status && "vkQueueInsertDebugUtilsLabelEXT");
5470 }
5471
5472 void WINAPI vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV *pQueueTypeInfo)
5473 {
5474     struct vkQueueNotifyOutOfBandNV_params params;
5475     NTSTATUS status;
5476     params.queue = queue;
5477     params.pQueueTypeInfo = pQueueTypeInfo;
5478     status = UNIX_CALL(vkQueueNotifyOutOfBandNV, &params);
5479     assert(!status && "vkQueueNotifyOutOfBandNV");
5480 }
5481
5482 VkResult WINAPI vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
5483 {
5484     struct vkQueuePresentKHR_params params;
5485     NTSTATUS status;
5486     params.queue = queue;
5487     params.pPresentInfo = pPresentInfo;
5488     status = UNIX_CALL(vkQueuePresentKHR, &params);
5489     assert(!status && "vkQueuePresentKHR");
5490     return params.result;
5491 }
5492
5493 VkResult WINAPI vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
5494 {
5495     struct vkQueueSetPerformanceConfigurationINTEL_params params;
5496     NTSTATUS status;
5497     params.queue = queue;
5498     params.configuration = configuration;
5499     status = UNIX_CALL(vkQueueSetPerformanceConfigurationINTEL, &params);
5500     assert(!status && "vkQueueSetPerformanceConfigurationINTEL");
5501     return params.result;
5502 }
5503
5504 VkResult WINAPI vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
5505 {
5506     struct vkQueueSubmit_params params;
5507     NTSTATUS status;
5508     params.queue = queue;
5509     params.submitCount = submitCount;
5510     params.pSubmits = pSubmits;
5511     params.fence = fence;
5512     status = UNIX_CALL(vkQueueSubmit, &params);
5513     assert(!status && "vkQueueSubmit");
5514     return params.result;
5515 }
5516
5517 VkResult WINAPI vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
5518 {
5519     struct vkQueueSubmit2_params params;
5520     NTSTATUS status;
5521     params.queue = queue;
5522     params.submitCount = submitCount;
5523     params.pSubmits = pSubmits;
5524     params.fence = fence;
5525     status = UNIX_CALL(vkQueueSubmit2, &params);
5526     assert(!status && "vkQueueSubmit2");
5527     return params.result;
5528 }
5529
5530 VkResult WINAPI vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
5531 {
5532     struct vkQueueSubmit2KHR_params params;
5533     NTSTATUS status;
5534     params.queue = queue;
5535     params.submitCount = submitCount;
5536     params.pSubmits = pSubmits;
5537     params.fence = fence;
5538     status = UNIX_CALL(vkQueueSubmit2KHR, &params);
5539     assert(!status && "vkQueueSubmit2KHR");
5540     return params.result;
5541 }
5542
5543 VkResult WINAPI vkQueueWaitIdle(VkQueue queue)
5544 {
5545     struct vkQueueWaitIdle_params params;
5546     NTSTATUS status;
5547     params.queue = queue;
5548     status = UNIX_CALL(vkQueueWaitIdle, &params);
5549     assert(!status && "vkQueueWaitIdle");
5550     return params.result;
5551 }
5552
5553 VkResult WINAPI vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
5554 {
5555     struct vkReleasePerformanceConfigurationINTEL_params params;
5556     NTSTATUS status;
5557     params.device = device;
5558     params.configuration = configuration;
5559     status = UNIX_CALL(vkReleasePerformanceConfigurationINTEL, &params);
5560     assert(!status && "vkReleasePerformanceConfigurationINTEL");
5561     return params.result;
5562 }
5563
5564 void WINAPI vkReleaseProfilingLockKHR(VkDevice device)
5565 {
5566     struct vkReleaseProfilingLockKHR_params params;
5567     NTSTATUS status;
5568     params.device = device;
5569     status = UNIX_CALL(vkReleaseProfilingLockKHR, &params);
5570     assert(!status && "vkReleaseProfilingLockKHR");
5571 }
5572
5573 VkResult WINAPI vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoEXT *pReleaseInfo)
5574 {
5575     struct vkReleaseSwapchainImagesEXT_params params;
5576     NTSTATUS status;
5577     params.device = device;
5578     params.pReleaseInfo = pReleaseInfo;
5579     status = UNIX_CALL(vkReleaseSwapchainImagesEXT, &params);
5580     assert(!status && "vkReleaseSwapchainImagesEXT");
5581     return params.result;
5582 }
5583
5584 VkResult WINAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
5585 {
5586     struct vkResetCommandBuffer_params params;
5587     NTSTATUS status;
5588     params.commandBuffer = commandBuffer;
5589     params.flags = flags;
5590     status = UNIX_CALL(vkResetCommandBuffer, &params);
5591     assert(!status && "vkResetCommandBuffer");
5592     return params.result;
5593 }
5594
5595 VkResult WINAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
5596 {
5597     struct vkResetCommandPool_params params;
5598     NTSTATUS status;
5599     params.device = device;
5600     params.commandPool = commandPool;
5601     params.flags = flags;
5602     status = UNIX_CALL(vkResetCommandPool, &params);
5603     assert(!status && "vkResetCommandPool");
5604     return params.result;
5605 }
5606
5607 VkResult WINAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
5608 {
5609     struct vkResetDescriptorPool_params params;
5610     NTSTATUS status;
5611     params.device = device;
5612     params.descriptorPool = descriptorPool;
5613     params.flags = flags;
5614     status = UNIX_CALL(vkResetDescriptorPool, &params);
5615     assert(!status && "vkResetDescriptorPool");
5616     return params.result;
5617 }
5618
5619 VkResult WINAPI vkResetEvent(VkDevice device, VkEvent event)
5620 {
5621     struct vkResetEvent_params params;
5622     NTSTATUS status;
5623     params.device = device;
5624     params.event = event;
5625     status = UNIX_CALL(vkResetEvent, &params);
5626     assert(!status && "vkResetEvent");
5627     return params.result;
5628 }
5629
5630 VkResult WINAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
5631 {
5632     struct vkResetFences_params params;
5633     NTSTATUS status;
5634     params.device = device;
5635     params.fenceCount = fenceCount;
5636     params.pFences = pFences;
5637     status = UNIX_CALL(vkResetFences, &params);
5638     assert(!status && "vkResetFences");
5639     return params.result;
5640 }
5641
5642 void WINAPI vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
5643 {
5644     struct vkResetQueryPool_params params;
5645     NTSTATUS status;
5646     params.device = device;
5647     params.queryPool = queryPool;
5648     params.firstQuery = firstQuery;
5649     params.queryCount = queryCount;
5650     status = UNIX_CALL(vkResetQueryPool, &params);
5651     assert(!status && "vkResetQueryPool");
5652 }
5653
5654 void WINAPI vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
5655 {
5656     struct vkResetQueryPoolEXT_params params;
5657     NTSTATUS status;
5658     params.device = device;
5659     params.queryPool = queryPool;
5660     params.firstQuery = firstQuery;
5661     params.queryCount = queryCount;
5662     status = UNIX_CALL(vkResetQueryPoolEXT, &params);
5663     assert(!status && "vkResetQueryPoolEXT");
5664 }
5665
5666 VkResult WINAPI vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
5667 {
5668     struct vkSetDebugUtilsObjectNameEXT_params params;
5669     NTSTATUS status;
5670     params.device = device;
5671     params.pNameInfo = pNameInfo;
5672     status = UNIX_CALL(vkSetDebugUtilsObjectNameEXT, &params);
5673     assert(!status && "vkSetDebugUtilsObjectNameEXT");
5674     return params.result;
5675 }
5676
5677 VkResult WINAPI vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
5678 {
5679     struct vkSetDebugUtilsObjectTagEXT_params params;
5680     NTSTATUS status;
5681     params.device = device;
5682     params.pTagInfo = pTagInfo;
5683     status = UNIX_CALL(vkSetDebugUtilsObjectTagEXT, &params);
5684     assert(!status && "vkSetDebugUtilsObjectTagEXT");
5685     return params.result;
5686 }
5687
5688 void WINAPI vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
5689 {
5690     struct vkSetDeviceMemoryPriorityEXT_params params;
5691     NTSTATUS status;
5692     params.device = device;
5693     params.memory = memory;
5694     params.priority = priority;
5695     status = UNIX_CALL(vkSetDeviceMemoryPriorityEXT, &params);
5696     assert(!status && "vkSetDeviceMemoryPriorityEXT");
5697 }
5698
5699 VkResult WINAPI vkSetEvent(VkDevice device, VkEvent event)
5700 {
5701     struct vkSetEvent_params params;
5702     NTSTATUS status;
5703     params.device = device;
5704     params.event = event;
5705     status = UNIX_CALL(vkSetEvent, &params);
5706     assert(!status && "vkSetEvent");
5707     return params.result;
5708 }
5709
5710 void WINAPI vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
5711 {
5712     struct vkSetHdrMetadataEXT_params params;
5713     NTSTATUS status;
5714     params.device = device;
5715     params.swapchainCount = swapchainCount;
5716     params.pSwapchains = pSwapchains;
5717     params.pMetadata = pMetadata;
5718     status = UNIX_CALL(vkSetHdrMetadataEXT, &params);
5719     assert(!status && "vkSetHdrMetadataEXT");
5720 }
5721
5722 void WINAPI vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV *pLatencyMarkerInfo)
5723 {
5724     struct vkSetLatencyMarkerNV_params params;
5725     NTSTATUS status;
5726     params.device = device;
5727     params.swapchain = swapchain;
5728     params.pLatencyMarkerInfo = pLatencyMarkerInfo;
5729     status = UNIX_CALL(vkSetLatencyMarkerNV, &params);
5730     assert(!status && "vkSetLatencyMarkerNV");
5731 }
5732
5733 VkResult WINAPI vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV *pSleepModeInfo)
5734 {
5735     struct vkSetLatencySleepModeNV_params params;
5736     NTSTATUS status;
5737     params.device = device;
5738     params.swapchain = swapchain;
5739     params.pSleepModeInfo = pSleepModeInfo;
5740     status = UNIX_CALL(vkSetLatencySleepModeNV, &params);
5741     assert(!status && "vkSetLatencySleepModeNV");
5742     return params.result;
5743 }
5744
5745 VkResult WINAPI vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
5746 {
5747     struct vkSetPrivateData_params params;
5748     NTSTATUS status;
5749     params.device = device;
5750     params.objectType = objectType;
5751     params.objectHandle = objectHandle;
5752     params.privateDataSlot = privateDataSlot;
5753     params.data = data;
5754     status = UNIX_CALL(vkSetPrivateData, &params);
5755     assert(!status && "vkSetPrivateData");
5756     return params.result;
5757 }
5758
5759 VkResult WINAPI vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
5760 {
5761     struct vkSetPrivateDataEXT_params params;
5762     NTSTATUS status;
5763     params.device = device;
5764     params.objectType = objectType;
5765     params.objectHandle = objectHandle;
5766     params.privateDataSlot = privateDataSlot;
5767     params.data = data;
5768     status = UNIX_CALL(vkSetPrivateDataEXT, &params);
5769     assert(!status && "vkSetPrivateDataEXT");
5770     return params.result;
5771 }
5772
5773 VkResult WINAPI vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
5774 {
5775     struct vkSignalSemaphore_params params;
5776     NTSTATUS status;
5777     params.device = device;
5778     params.pSignalInfo = pSignalInfo;
5779     status = UNIX_CALL(vkSignalSemaphore, &params);
5780     assert(!status && "vkSignalSemaphore");
5781     return params.result;
5782 }
5783
5784 VkResult WINAPI vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
5785 {
5786     struct vkSignalSemaphoreKHR_params params;
5787     NTSTATUS status;
5788     params.device = device;
5789     params.pSignalInfo = pSignalInfo;
5790     status = UNIX_CALL(vkSignalSemaphoreKHR, &params);
5791     assert(!status && "vkSignalSemaphoreKHR");
5792     return params.result;
5793 }
5794
5795 void WINAPI vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
5796 {
5797     struct vkSubmitDebugUtilsMessageEXT_params params;
5798     NTSTATUS status;
5799     params.instance = instance;
5800     params.messageSeverity = messageSeverity;
5801     params.messageTypes = messageTypes;
5802     params.pCallbackData = pCallbackData;
5803     status = UNIX_CALL(vkSubmitDebugUtilsMessageEXT, &params);
5804     assert(!status && "vkSubmitDebugUtilsMessageEXT");
5805 }
5806
5807 VkResult WINAPI vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT *pTransitions)
5808 {
5809     struct vkTransitionImageLayoutEXT_params params;
5810     NTSTATUS status;
5811     params.device = device;
5812     params.transitionCount = transitionCount;
5813     params.pTransitions = pTransitions;
5814     status = UNIX_CALL(vkTransitionImageLayoutEXT, &params);
5815     assert(!status && "vkTransitionImageLayoutEXT");
5816     return params.result;
5817 }
5818
5819 void WINAPI vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
5820 {
5821     struct vkTrimCommandPool_params params;
5822     NTSTATUS status;
5823     params.device = device;
5824     params.commandPool = commandPool;
5825     params.flags = flags;
5826     status = UNIX_CALL(vkTrimCommandPool, &params);
5827     assert(!status && "vkTrimCommandPool");
5828 }
5829
5830 void WINAPI vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
5831 {
5832     struct vkTrimCommandPoolKHR_params params;
5833     NTSTATUS status;
5834     params.device = device;
5835     params.commandPool = commandPool;
5836     params.flags = flags;
5837     status = UNIX_CALL(vkTrimCommandPoolKHR, &params);
5838     assert(!status && "vkTrimCommandPoolKHR");
5839 }
5840
5841 void WINAPI vkUninitializePerformanceApiINTEL(VkDevice device)
5842 {
5843     struct vkUninitializePerformanceApiINTEL_params params;
5844     NTSTATUS status;
5845     params.device = device;
5846     status = UNIX_CALL(vkUninitializePerformanceApiINTEL, &params);
5847     assert(!status && "vkUninitializePerformanceApiINTEL");
5848 }
5849
5850 void WINAPI vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
5851 {
5852     struct vkUnmapMemory_params params;
5853     NTSTATUS status;
5854     params.device = device;
5855     params.memory = memory;
5856     status = UNIX_CALL(vkUnmapMemory, &params);
5857     assert(!status && "vkUnmapMemory");
5858 }
5859
5860 VkResult WINAPI vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR *pMemoryUnmapInfo)
5861 {
5862     struct vkUnmapMemory2KHR_params params;
5863     NTSTATUS status;
5864     params.device = device;
5865     params.pMemoryUnmapInfo = pMemoryUnmapInfo;
5866     status = UNIX_CALL(vkUnmapMemory2KHR, &params);
5867     assert(!status && "vkUnmapMemory2KHR");
5868     return params.result;
5869 }
5870
5871 void WINAPI vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
5872 {
5873     struct vkUpdateDescriptorSetWithTemplate_params params;
5874     params.device = device;
5875     params.descriptorSet = descriptorSet;
5876     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
5877     params.pData = pData;
5878     UNIX_CALL(vkUpdateDescriptorSetWithTemplate, &params);
5879 }
5880
5881 void WINAPI vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
5882 {
5883     struct vkUpdateDescriptorSetWithTemplateKHR_params params;
5884     NTSTATUS status;
5885     params.device = device;
5886     params.descriptorSet = descriptorSet;
5887     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
5888     params.pData = pData;
5889     status = UNIX_CALL(vkUpdateDescriptorSetWithTemplateKHR, &params);
5890     assert(!status && "vkUpdateDescriptorSetWithTemplateKHR");
5891 }
5892
5893 void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
5894 {
5895     struct vkUpdateDescriptorSets_params params;
5896     params.device = device;
5897     params.descriptorWriteCount = descriptorWriteCount;
5898     params.pDescriptorWrites = pDescriptorWrites;
5899     params.descriptorCopyCount = descriptorCopyCount;
5900     params.pDescriptorCopies = pDescriptorCopies;
5901     UNIX_CALL(vkUpdateDescriptorSets, &params);
5902 }
5903
5904 VkResult WINAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
5905 {
5906     struct vkWaitForFences_params params;
5907     NTSTATUS status;
5908     params.device = device;
5909     params.fenceCount = fenceCount;
5910     params.pFences = pFences;
5911     params.waitAll = waitAll;
5912     params.timeout = timeout;
5913     status = UNIX_CALL(vkWaitForFences, &params);
5914     assert(!status && "vkWaitForFences");
5915     return params.result;
5916 }
5917
5918 VkResult WINAPI vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
5919 {
5920     struct vkWaitForPresentKHR_params params;
5921     NTSTATUS status;
5922     params.device = device;
5923     params.swapchain = swapchain;
5924     params.presentId = presentId;
5925     params.timeout = timeout;
5926     status = UNIX_CALL(vkWaitForPresentKHR, &params);
5927     assert(!status && "vkWaitForPresentKHR");
5928     return params.result;
5929 }
5930
5931 VkResult WINAPI vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
5932 {
5933     struct vkWaitSemaphores_params params;
5934     NTSTATUS status;
5935     params.device = device;
5936     params.pWaitInfo = pWaitInfo;
5937     params.timeout = timeout;
5938     status = UNIX_CALL(vkWaitSemaphores, &params);
5939     assert(!status && "vkWaitSemaphores");
5940     return params.result;
5941 }
5942
5943 VkResult WINAPI vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
5944 {
5945     struct vkWaitSemaphoresKHR_params params;
5946     NTSTATUS status;
5947     params.device = device;
5948     params.pWaitInfo = pWaitInfo;
5949     params.timeout = timeout;
5950     status = UNIX_CALL(vkWaitSemaphoresKHR, &params);
5951     assert(!status && "vkWaitSemaphoresKHR");
5952     return params.result;
5953 }
5954
5955 VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
5956 {
5957     struct vkWriteAccelerationStructuresPropertiesKHR_params params;
5958     NTSTATUS status;
5959     params.device = device;
5960     params.accelerationStructureCount = accelerationStructureCount;
5961     params.pAccelerationStructures = pAccelerationStructures;
5962     params.queryType = queryType;
5963     params.dataSize = dataSize;
5964     params.pData = pData;
5965     params.stride = stride;
5966     status = UNIX_CALL(vkWriteAccelerationStructuresPropertiesKHR, &params);
5967     assert(!status && "vkWriteAccelerationStructuresPropertiesKHR");
5968     return params.result;
5969 }
5970
5971 VkResult WINAPI vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
5972 {
5973     struct vkWriteMicromapsPropertiesEXT_params params;
5974     NTSTATUS status;
5975     params.device = device;
5976     params.micromapCount = micromapCount;
5977     params.pMicromaps = pMicromaps;
5978     params.queryType = queryType;
5979     params.dataSize = dataSize;
5980     params.pData = pData;
5981     params.stride = stride;
5982     status = UNIX_CALL(vkWriteMicromapsPropertiesEXT, &params);
5983     assert(!status && "vkWriteMicromapsPropertiesEXT");
5984     return params.result;
5985 }
5986
5987 static const struct vulkan_func vk_device_dispatch_table[] =
5988 {
5989     {"vkAcquireNextImage2KHR", vkAcquireNextImage2KHR},
5990     {"vkAcquireNextImageKHR", vkAcquireNextImageKHR},
5991     {"vkAcquirePerformanceConfigurationINTEL", vkAcquirePerformanceConfigurationINTEL},
5992     {"vkAcquireProfilingLockKHR", vkAcquireProfilingLockKHR},
5993     {"vkAllocateCommandBuffers", vkAllocateCommandBuffers},
5994     {"vkAllocateDescriptorSets", vkAllocateDescriptorSets},
5995     {"vkAllocateMemory", vkAllocateMemory},
5996     {"vkBeginCommandBuffer", vkBeginCommandBuffer},
5997     {"vkBindAccelerationStructureMemoryNV", vkBindAccelerationStructureMemoryNV},
5998     {"vkBindBufferMemory", vkBindBufferMemory},
5999     {"vkBindBufferMemory2", vkBindBufferMemory2},
6000     {"vkBindBufferMemory2KHR", vkBindBufferMemory2KHR},
6001     {"vkBindImageMemory", vkBindImageMemory},
6002     {"vkBindImageMemory2", vkBindImageMemory2},
6003     {"vkBindImageMemory2KHR", vkBindImageMemory2KHR},
6004     {"vkBindOpticalFlowSessionImageNV", vkBindOpticalFlowSessionImageNV},
6005     {"vkBuildAccelerationStructuresKHR", vkBuildAccelerationStructuresKHR},
6006     {"vkBuildMicromapsEXT", vkBuildMicromapsEXT},
6007     {"vkCmdBeginConditionalRenderingEXT", vkCmdBeginConditionalRenderingEXT},
6008     {"vkCmdBeginDebugUtilsLabelEXT", vkCmdBeginDebugUtilsLabelEXT},
6009     {"vkCmdBeginQuery", vkCmdBeginQuery},
6010     {"vkCmdBeginQueryIndexedEXT", vkCmdBeginQueryIndexedEXT},
6011     {"vkCmdBeginRenderPass", vkCmdBeginRenderPass},
6012     {"vkCmdBeginRenderPass2", vkCmdBeginRenderPass2},
6013     {"vkCmdBeginRenderPass2KHR", vkCmdBeginRenderPass2KHR},
6014     {"vkCmdBeginRendering", vkCmdBeginRendering},
6015     {"vkCmdBeginRenderingKHR", vkCmdBeginRenderingKHR},
6016     {"vkCmdBeginTransformFeedbackEXT", vkCmdBeginTransformFeedbackEXT},
6017     {"vkCmdBindDescriptorBufferEmbeddedSamplersEXT", vkCmdBindDescriptorBufferEmbeddedSamplersEXT},
6018     {"vkCmdBindDescriptorBuffersEXT", vkCmdBindDescriptorBuffersEXT},
6019     {"vkCmdBindDescriptorSets", vkCmdBindDescriptorSets},
6020     {"vkCmdBindIndexBuffer", vkCmdBindIndexBuffer},
6021     {"vkCmdBindIndexBuffer2KHR", vkCmdBindIndexBuffer2KHR},
6022     {"vkCmdBindInvocationMaskHUAWEI", vkCmdBindInvocationMaskHUAWEI},
6023     {"vkCmdBindPipeline", vkCmdBindPipeline},
6024     {"vkCmdBindPipelineShaderGroupNV", vkCmdBindPipelineShaderGroupNV},
6025     {"vkCmdBindShadersEXT", vkCmdBindShadersEXT},
6026     {"vkCmdBindShadingRateImageNV", vkCmdBindShadingRateImageNV},
6027     {"vkCmdBindTransformFeedbackBuffersEXT", vkCmdBindTransformFeedbackBuffersEXT},
6028     {"vkCmdBindVertexBuffers", vkCmdBindVertexBuffers},
6029     {"vkCmdBindVertexBuffers2", vkCmdBindVertexBuffers2},
6030     {"vkCmdBindVertexBuffers2EXT", vkCmdBindVertexBuffers2EXT},
6031     {"vkCmdBlitImage", vkCmdBlitImage},
6032     {"vkCmdBlitImage2", vkCmdBlitImage2},
6033     {"vkCmdBlitImage2KHR", vkCmdBlitImage2KHR},
6034     {"vkCmdBuildAccelerationStructureNV", vkCmdBuildAccelerationStructureNV},
6035     {"vkCmdBuildAccelerationStructuresIndirectKHR", vkCmdBuildAccelerationStructuresIndirectKHR},
6036     {"vkCmdBuildAccelerationStructuresKHR", vkCmdBuildAccelerationStructuresKHR},
6037     {"vkCmdBuildMicromapsEXT", vkCmdBuildMicromapsEXT},
6038     {"vkCmdClearAttachments", vkCmdClearAttachments},
6039     {"vkCmdClearColorImage", vkCmdClearColorImage},
6040     {"vkCmdClearDepthStencilImage", vkCmdClearDepthStencilImage},
6041     {"vkCmdCopyAccelerationStructureKHR", vkCmdCopyAccelerationStructureKHR},
6042     {"vkCmdCopyAccelerationStructureNV", vkCmdCopyAccelerationStructureNV},
6043     {"vkCmdCopyAccelerationStructureToMemoryKHR", vkCmdCopyAccelerationStructureToMemoryKHR},
6044     {"vkCmdCopyBuffer", vkCmdCopyBuffer},
6045     {"vkCmdCopyBuffer2", vkCmdCopyBuffer2},
6046     {"vkCmdCopyBuffer2KHR", vkCmdCopyBuffer2KHR},
6047     {"vkCmdCopyBufferToImage", vkCmdCopyBufferToImage},
6048     {"vkCmdCopyBufferToImage2", vkCmdCopyBufferToImage2},
6049     {"vkCmdCopyBufferToImage2KHR", vkCmdCopyBufferToImage2KHR},
6050     {"vkCmdCopyImage", vkCmdCopyImage},
6051     {"vkCmdCopyImage2", vkCmdCopyImage2},
6052     {"vkCmdCopyImage2KHR", vkCmdCopyImage2KHR},
6053     {"vkCmdCopyImageToBuffer", vkCmdCopyImageToBuffer},
6054     {"vkCmdCopyImageToBuffer2", vkCmdCopyImageToBuffer2},
6055     {"vkCmdCopyImageToBuffer2KHR", vkCmdCopyImageToBuffer2KHR},
6056     {"vkCmdCopyMemoryIndirectNV", vkCmdCopyMemoryIndirectNV},
6057     {"vkCmdCopyMemoryToAccelerationStructureKHR", vkCmdCopyMemoryToAccelerationStructureKHR},
6058     {"vkCmdCopyMemoryToImageIndirectNV", vkCmdCopyMemoryToImageIndirectNV},
6059     {"vkCmdCopyMemoryToMicromapEXT", vkCmdCopyMemoryToMicromapEXT},
6060     {"vkCmdCopyMicromapEXT", vkCmdCopyMicromapEXT},
6061     {"vkCmdCopyMicromapToMemoryEXT", vkCmdCopyMicromapToMemoryEXT},
6062     {"vkCmdCopyQueryPoolResults", vkCmdCopyQueryPoolResults},
6063     {"vkCmdCuLaunchKernelNVX", vkCmdCuLaunchKernelNVX},
6064     {"vkCmdDebugMarkerBeginEXT", vkCmdDebugMarkerBeginEXT},
6065     {"vkCmdDebugMarkerEndEXT", vkCmdDebugMarkerEndEXT},
6066     {"vkCmdDebugMarkerInsertEXT", vkCmdDebugMarkerInsertEXT},
6067     {"vkCmdDecompressMemoryIndirectCountNV", vkCmdDecompressMemoryIndirectCountNV},
6068     {"vkCmdDecompressMemoryNV", vkCmdDecompressMemoryNV},
6069     {"vkCmdDispatch", vkCmdDispatch},
6070     {"vkCmdDispatchBase", vkCmdDispatchBase},
6071     {"vkCmdDispatchBaseKHR", vkCmdDispatchBaseKHR},
6072     {"vkCmdDispatchIndirect", vkCmdDispatchIndirect},
6073     {"vkCmdDraw", vkCmdDraw},
6074     {"vkCmdDrawClusterHUAWEI", vkCmdDrawClusterHUAWEI},
6075     {"vkCmdDrawClusterIndirectHUAWEI", vkCmdDrawClusterIndirectHUAWEI},
6076     {"vkCmdDrawIndexed", vkCmdDrawIndexed},
6077     {"vkCmdDrawIndexedIndirect", vkCmdDrawIndexedIndirect},
6078     {"vkCmdDrawIndexedIndirectCount", vkCmdDrawIndexedIndirectCount},
6079     {"vkCmdDrawIndexedIndirectCountAMD", vkCmdDrawIndexedIndirectCountAMD},
6080     {"vkCmdDrawIndexedIndirectCountKHR", vkCmdDrawIndexedIndirectCountKHR},
6081     {"vkCmdDrawIndirect", vkCmdDrawIndirect},
6082     {"vkCmdDrawIndirectByteCountEXT", vkCmdDrawIndirectByteCountEXT},
6083     {"vkCmdDrawIndirectCount", vkCmdDrawIndirectCount},
6084     {"vkCmdDrawIndirectCountAMD", vkCmdDrawIndirectCountAMD},
6085     {"vkCmdDrawIndirectCountKHR", vkCmdDrawIndirectCountKHR},
6086     {"vkCmdDrawMeshTasksEXT", vkCmdDrawMeshTasksEXT},
6087     {"vkCmdDrawMeshTasksIndirectCountEXT", vkCmdDrawMeshTasksIndirectCountEXT},
6088     {"vkCmdDrawMeshTasksIndirectCountNV", vkCmdDrawMeshTasksIndirectCountNV},
6089     {"vkCmdDrawMeshTasksIndirectEXT", vkCmdDrawMeshTasksIndirectEXT},
6090     {"vkCmdDrawMeshTasksIndirectNV", vkCmdDrawMeshTasksIndirectNV},
6091     {"vkCmdDrawMeshTasksNV", vkCmdDrawMeshTasksNV},
6092     {"vkCmdDrawMultiEXT", vkCmdDrawMultiEXT},
6093     {"vkCmdDrawMultiIndexedEXT", vkCmdDrawMultiIndexedEXT},
6094     {"vkCmdEndConditionalRenderingEXT", vkCmdEndConditionalRenderingEXT},
6095     {"vkCmdEndDebugUtilsLabelEXT", vkCmdEndDebugUtilsLabelEXT},
6096     {"vkCmdEndQuery", vkCmdEndQuery},
6097     {"vkCmdEndQueryIndexedEXT", vkCmdEndQueryIndexedEXT},
6098     {"vkCmdEndRenderPass", vkCmdEndRenderPass},
6099     {"vkCmdEndRenderPass2", vkCmdEndRenderPass2},
6100     {"vkCmdEndRenderPass2KHR", vkCmdEndRenderPass2KHR},
6101     {"vkCmdEndRendering", vkCmdEndRendering},
6102     {"vkCmdEndRenderingKHR", vkCmdEndRenderingKHR},
6103     {"vkCmdEndTransformFeedbackEXT", vkCmdEndTransformFeedbackEXT},
6104     {"vkCmdExecuteCommands", vkCmdExecuteCommands},
6105     {"vkCmdExecuteGeneratedCommandsNV", vkCmdExecuteGeneratedCommandsNV},
6106     {"vkCmdFillBuffer", vkCmdFillBuffer},
6107     {"vkCmdInsertDebugUtilsLabelEXT", vkCmdInsertDebugUtilsLabelEXT},
6108     {"vkCmdNextSubpass", vkCmdNextSubpass},
6109     {"vkCmdNextSubpass2", vkCmdNextSubpass2},
6110     {"vkCmdNextSubpass2KHR", vkCmdNextSubpass2KHR},
6111     {"vkCmdOpticalFlowExecuteNV", vkCmdOpticalFlowExecuteNV},
6112     {"vkCmdPipelineBarrier", vkCmdPipelineBarrier},
6113     {"vkCmdPipelineBarrier2", vkCmdPipelineBarrier2},
6114     {"vkCmdPipelineBarrier2KHR", vkCmdPipelineBarrier2KHR},
6115     {"vkCmdPreprocessGeneratedCommandsNV", vkCmdPreprocessGeneratedCommandsNV},
6116     {"vkCmdPushConstants", vkCmdPushConstants},
6117     {"vkCmdPushDescriptorSetKHR", vkCmdPushDescriptorSetKHR},
6118     {"vkCmdPushDescriptorSetWithTemplateKHR", vkCmdPushDescriptorSetWithTemplateKHR},
6119     {"vkCmdResetEvent", vkCmdResetEvent},
6120     {"vkCmdResetEvent2", vkCmdResetEvent2},
6121     {"vkCmdResetEvent2KHR", vkCmdResetEvent2KHR},
6122     {"vkCmdResetQueryPool", vkCmdResetQueryPool},
6123     {"vkCmdResolveImage", vkCmdResolveImage},
6124     {"vkCmdResolveImage2", vkCmdResolveImage2},
6125     {"vkCmdResolveImage2KHR", vkCmdResolveImage2KHR},
6126     {"vkCmdSetAlphaToCoverageEnableEXT", vkCmdSetAlphaToCoverageEnableEXT},
6127     {"vkCmdSetAlphaToOneEnableEXT", vkCmdSetAlphaToOneEnableEXT},
6128     {"vkCmdSetAttachmentFeedbackLoopEnableEXT", vkCmdSetAttachmentFeedbackLoopEnableEXT},
6129     {"vkCmdSetBlendConstants", vkCmdSetBlendConstants},
6130     {"vkCmdSetCheckpointNV", vkCmdSetCheckpointNV},
6131     {"vkCmdSetCoarseSampleOrderNV", vkCmdSetCoarseSampleOrderNV},
6132     {"vkCmdSetColorBlendAdvancedEXT", vkCmdSetColorBlendAdvancedEXT},
6133     {"vkCmdSetColorBlendEnableEXT", vkCmdSetColorBlendEnableEXT},
6134     {"vkCmdSetColorBlendEquationEXT", vkCmdSetColorBlendEquationEXT},
6135     {"vkCmdSetColorWriteEnableEXT", vkCmdSetColorWriteEnableEXT},
6136     {"vkCmdSetColorWriteMaskEXT", vkCmdSetColorWriteMaskEXT},
6137     {"vkCmdSetConservativeRasterizationModeEXT", vkCmdSetConservativeRasterizationModeEXT},
6138     {"vkCmdSetCoverageModulationModeNV", vkCmdSetCoverageModulationModeNV},
6139     {"vkCmdSetCoverageModulationTableEnableNV", vkCmdSetCoverageModulationTableEnableNV},
6140     {"vkCmdSetCoverageModulationTableNV", vkCmdSetCoverageModulationTableNV},
6141     {"vkCmdSetCoverageReductionModeNV", vkCmdSetCoverageReductionModeNV},
6142     {"vkCmdSetCoverageToColorEnableNV", vkCmdSetCoverageToColorEnableNV},
6143     {"vkCmdSetCoverageToColorLocationNV", vkCmdSetCoverageToColorLocationNV},
6144     {"vkCmdSetCullMode", vkCmdSetCullMode},
6145     {"vkCmdSetCullModeEXT", vkCmdSetCullModeEXT},
6146     {"vkCmdSetDepthBias", vkCmdSetDepthBias},
6147     {"vkCmdSetDepthBias2EXT", vkCmdSetDepthBias2EXT},
6148     {"vkCmdSetDepthBiasEnable", vkCmdSetDepthBiasEnable},
6149     {"vkCmdSetDepthBiasEnableEXT", vkCmdSetDepthBiasEnableEXT},
6150     {"vkCmdSetDepthBounds", vkCmdSetDepthBounds},
6151     {"vkCmdSetDepthBoundsTestEnable", vkCmdSetDepthBoundsTestEnable},
6152     {"vkCmdSetDepthBoundsTestEnableEXT", vkCmdSetDepthBoundsTestEnableEXT},
6153     {"vkCmdSetDepthClampEnableEXT", vkCmdSetDepthClampEnableEXT},
6154     {"vkCmdSetDepthClipEnableEXT", vkCmdSetDepthClipEnableEXT},
6155     {"vkCmdSetDepthClipNegativeOneToOneEXT", vkCmdSetDepthClipNegativeOneToOneEXT},
6156     {"vkCmdSetDepthCompareOp", vkCmdSetDepthCompareOp},
6157     {"vkCmdSetDepthCompareOpEXT", vkCmdSetDepthCompareOpEXT},
6158     {"vkCmdSetDepthTestEnable", vkCmdSetDepthTestEnable},
6159     {"vkCmdSetDepthTestEnableEXT", vkCmdSetDepthTestEnableEXT},
6160     {"vkCmdSetDepthWriteEnable", vkCmdSetDepthWriteEnable},
6161     {"vkCmdSetDepthWriteEnableEXT", vkCmdSetDepthWriteEnableEXT},
6162     {"vkCmdSetDescriptorBufferOffsetsEXT", vkCmdSetDescriptorBufferOffsetsEXT},
6163     {"vkCmdSetDeviceMask", vkCmdSetDeviceMask},
6164     {"vkCmdSetDeviceMaskKHR", vkCmdSetDeviceMaskKHR},
6165     {"vkCmdSetDiscardRectangleEXT", vkCmdSetDiscardRectangleEXT},
6166     {"vkCmdSetDiscardRectangleEnableEXT", vkCmdSetDiscardRectangleEnableEXT},
6167     {"vkCmdSetDiscardRectangleModeEXT", vkCmdSetDiscardRectangleModeEXT},
6168     {"vkCmdSetEvent", vkCmdSetEvent},
6169     {"vkCmdSetEvent2", vkCmdSetEvent2},
6170     {"vkCmdSetEvent2KHR", vkCmdSetEvent2KHR},
6171     {"vkCmdSetExclusiveScissorEnableNV", vkCmdSetExclusiveScissorEnableNV},
6172     {"vkCmdSetExclusiveScissorNV", vkCmdSetExclusiveScissorNV},
6173     {"vkCmdSetExtraPrimitiveOverestimationSizeEXT", vkCmdSetExtraPrimitiveOverestimationSizeEXT},
6174     {"vkCmdSetFragmentShadingRateEnumNV", vkCmdSetFragmentShadingRateEnumNV},
6175     {"vkCmdSetFragmentShadingRateKHR", vkCmdSetFragmentShadingRateKHR},
6176     {"vkCmdSetFrontFace", vkCmdSetFrontFace},
6177     {"vkCmdSetFrontFaceEXT", vkCmdSetFrontFaceEXT},
6178     {"vkCmdSetLineRasterizationModeEXT", vkCmdSetLineRasterizationModeEXT},
6179     {"vkCmdSetLineStippleEXT", vkCmdSetLineStippleEXT},
6180     {"vkCmdSetLineStippleEnableEXT", vkCmdSetLineStippleEnableEXT},
6181     {"vkCmdSetLineWidth", vkCmdSetLineWidth},
6182     {"vkCmdSetLogicOpEXT", vkCmdSetLogicOpEXT},
6183     {"vkCmdSetLogicOpEnableEXT", vkCmdSetLogicOpEnableEXT},
6184     {"vkCmdSetPatchControlPointsEXT", vkCmdSetPatchControlPointsEXT},
6185     {"vkCmdSetPerformanceMarkerINTEL", vkCmdSetPerformanceMarkerINTEL},
6186     {"vkCmdSetPerformanceOverrideINTEL", vkCmdSetPerformanceOverrideINTEL},
6187     {"vkCmdSetPerformanceStreamMarkerINTEL", vkCmdSetPerformanceStreamMarkerINTEL},
6188     {"vkCmdSetPolygonModeEXT", vkCmdSetPolygonModeEXT},
6189     {"vkCmdSetPrimitiveRestartEnable", vkCmdSetPrimitiveRestartEnable},
6190     {"vkCmdSetPrimitiveRestartEnableEXT", vkCmdSetPrimitiveRestartEnableEXT},
6191     {"vkCmdSetPrimitiveTopology", vkCmdSetPrimitiveTopology},
6192     {"vkCmdSetPrimitiveTopologyEXT", vkCmdSetPrimitiveTopologyEXT},
6193     {"vkCmdSetProvokingVertexModeEXT", vkCmdSetProvokingVertexModeEXT},
6194     {"vkCmdSetRasterizationSamplesEXT", vkCmdSetRasterizationSamplesEXT},
6195     {"vkCmdSetRasterizationStreamEXT", vkCmdSetRasterizationStreamEXT},
6196     {"vkCmdSetRasterizerDiscardEnable", vkCmdSetRasterizerDiscardEnable},
6197     {"vkCmdSetRasterizerDiscardEnableEXT", vkCmdSetRasterizerDiscardEnableEXT},
6198     {"vkCmdSetRayTracingPipelineStackSizeKHR", vkCmdSetRayTracingPipelineStackSizeKHR},
6199     {"vkCmdSetRepresentativeFragmentTestEnableNV", vkCmdSetRepresentativeFragmentTestEnableNV},
6200     {"vkCmdSetSampleLocationsEXT", vkCmdSetSampleLocationsEXT},
6201     {"vkCmdSetSampleLocationsEnableEXT", vkCmdSetSampleLocationsEnableEXT},
6202     {"vkCmdSetSampleMaskEXT", vkCmdSetSampleMaskEXT},
6203     {"vkCmdSetScissor", vkCmdSetScissor},
6204     {"vkCmdSetScissorWithCount", vkCmdSetScissorWithCount},
6205     {"vkCmdSetScissorWithCountEXT", vkCmdSetScissorWithCountEXT},
6206     {"vkCmdSetShadingRateImageEnableNV", vkCmdSetShadingRateImageEnableNV},
6207     {"vkCmdSetStencilCompareMask", vkCmdSetStencilCompareMask},
6208     {"vkCmdSetStencilOp", vkCmdSetStencilOp},
6209     {"vkCmdSetStencilOpEXT", vkCmdSetStencilOpEXT},
6210     {"vkCmdSetStencilReference", vkCmdSetStencilReference},
6211     {"vkCmdSetStencilTestEnable", vkCmdSetStencilTestEnable},
6212     {"vkCmdSetStencilTestEnableEXT", vkCmdSetStencilTestEnableEXT},
6213     {"vkCmdSetStencilWriteMask", vkCmdSetStencilWriteMask},
6214     {"vkCmdSetTessellationDomainOriginEXT", vkCmdSetTessellationDomainOriginEXT},
6215     {"vkCmdSetVertexInputEXT", vkCmdSetVertexInputEXT},
6216     {"vkCmdSetViewport", vkCmdSetViewport},
6217     {"vkCmdSetViewportShadingRatePaletteNV", vkCmdSetViewportShadingRatePaletteNV},
6218     {"vkCmdSetViewportSwizzleNV", vkCmdSetViewportSwizzleNV},
6219     {"vkCmdSetViewportWScalingEnableNV", vkCmdSetViewportWScalingEnableNV},
6220     {"vkCmdSetViewportWScalingNV", vkCmdSetViewportWScalingNV},
6221     {"vkCmdSetViewportWithCount", vkCmdSetViewportWithCount},
6222     {"vkCmdSetViewportWithCountEXT", vkCmdSetViewportWithCountEXT},
6223     {"vkCmdSubpassShadingHUAWEI", vkCmdSubpassShadingHUAWEI},
6224     {"vkCmdTraceRaysIndirect2KHR", vkCmdTraceRaysIndirect2KHR},
6225     {"vkCmdTraceRaysIndirectKHR", vkCmdTraceRaysIndirectKHR},
6226     {"vkCmdTraceRaysKHR", vkCmdTraceRaysKHR},
6227     {"vkCmdTraceRaysNV", vkCmdTraceRaysNV},
6228     {"vkCmdUpdateBuffer", vkCmdUpdateBuffer},
6229     {"vkCmdUpdatePipelineIndirectBufferNV", vkCmdUpdatePipelineIndirectBufferNV},
6230     {"vkCmdWaitEvents", vkCmdWaitEvents},
6231     {"vkCmdWaitEvents2", vkCmdWaitEvents2},
6232     {"vkCmdWaitEvents2KHR", vkCmdWaitEvents2KHR},
6233     {"vkCmdWriteAccelerationStructuresPropertiesKHR", vkCmdWriteAccelerationStructuresPropertiesKHR},
6234     {"vkCmdWriteAccelerationStructuresPropertiesNV", vkCmdWriteAccelerationStructuresPropertiesNV},
6235     {"vkCmdWriteBufferMarker2AMD", vkCmdWriteBufferMarker2AMD},
6236     {"vkCmdWriteBufferMarkerAMD", vkCmdWriteBufferMarkerAMD},
6237     {"vkCmdWriteMicromapsPropertiesEXT", vkCmdWriteMicromapsPropertiesEXT},
6238     {"vkCmdWriteTimestamp", vkCmdWriteTimestamp},
6239     {"vkCmdWriteTimestamp2", vkCmdWriteTimestamp2},
6240     {"vkCmdWriteTimestamp2KHR", vkCmdWriteTimestamp2KHR},
6241     {"vkCompileDeferredNV", vkCompileDeferredNV},
6242     {"vkCopyAccelerationStructureKHR", vkCopyAccelerationStructureKHR},
6243     {"vkCopyAccelerationStructureToMemoryKHR", vkCopyAccelerationStructureToMemoryKHR},
6244     {"vkCopyImageToImageEXT", vkCopyImageToImageEXT},
6245     {"vkCopyImageToMemoryEXT", vkCopyImageToMemoryEXT},
6246     {"vkCopyMemoryToAccelerationStructureKHR", vkCopyMemoryToAccelerationStructureKHR},
6247     {"vkCopyMemoryToImageEXT", vkCopyMemoryToImageEXT},
6248     {"vkCopyMemoryToMicromapEXT", vkCopyMemoryToMicromapEXT},
6249     {"vkCopyMicromapEXT", vkCopyMicromapEXT},
6250     {"vkCopyMicromapToMemoryEXT", vkCopyMicromapToMemoryEXT},
6251     {"vkCreateAccelerationStructureKHR", vkCreateAccelerationStructureKHR},
6252     {"vkCreateAccelerationStructureNV", vkCreateAccelerationStructureNV},
6253     {"vkCreateBuffer", vkCreateBuffer},
6254     {"vkCreateBufferView", vkCreateBufferView},
6255     {"vkCreateCommandPool", vkCreateCommandPool},
6256     {"vkCreateComputePipelines", vkCreateComputePipelines},
6257     {"vkCreateCuFunctionNVX", vkCreateCuFunctionNVX},
6258     {"vkCreateCuModuleNVX", vkCreateCuModuleNVX},
6259     {"vkCreateDeferredOperationKHR", vkCreateDeferredOperationKHR},
6260     {"vkCreateDescriptorPool", vkCreateDescriptorPool},
6261     {"vkCreateDescriptorSetLayout", vkCreateDescriptorSetLayout},
6262     {"vkCreateDescriptorUpdateTemplate", vkCreateDescriptorUpdateTemplate},
6263     {"vkCreateDescriptorUpdateTemplateKHR", vkCreateDescriptorUpdateTemplateKHR},
6264     {"vkCreateEvent", vkCreateEvent},
6265     {"vkCreateFence", vkCreateFence},
6266     {"vkCreateFramebuffer", vkCreateFramebuffer},
6267     {"vkCreateGraphicsPipelines", vkCreateGraphicsPipelines},
6268     {"vkCreateImage", vkCreateImage},
6269     {"vkCreateImageView", vkCreateImageView},
6270     {"vkCreateIndirectCommandsLayoutNV", vkCreateIndirectCommandsLayoutNV},
6271     {"vkCreateMicromapEXT", vkCreateMicromapEXT},
6272     {"vkCreateOpticalFlowSessionNV", vkCreateOpticalFlowSessionNV},
6273     {"vkCreatePipelineCache", vkCreatePipelineCache},
6274     {"vkCreatePipelineLayout", vkCreatePipelineLayout},
6275     {"vkCreatePrivateDataSlot", vkCreatePrivateDataSlot},
6276     {"vkCreatePrivateDataSlotEXT", vkCreatePrivateDataSlotEXT},
6277     {"vkCreateQueryPool", vkCreateQueryPool},
6278     {"vkCreateRayTracingPipelinesKHR", vkCreateRayTracingPipelinesKHR},
6279     {"vkCreateRayTracingPipelinesNV", vkCreateRayTracingPipelinesNV},
6280     {"vkCreateRenderPass", vkCreateRenderPass},
6281     {"vkCreateRenderPass2", vkCreateRenderPass2},
6282     {"vkCreateRenderPass2KHR", vkCreateRenderPass2KHR},
6283     {"vkCreateSampler", vkCreateSampler},
6284     {"vkCreateSamplerYcbcrConversion", vkCreateSamplerYcbcrConversion},
6285     {"vkCreateSamplerYcbcrConversionKHR", vkCreateSamplerYcbcrConversionKHR},
6286     {"vkCreateSemaphore", vkCreateSemaphore},
6287     {"vkCreateShaderModule", vkCreateShaderModule},
6288     {"vkCreateShadersEXT", vkCreateShadersEXT},
6289     {"vkCreateSwapchainKHR", vkCreateSwapchainKHR},
6290     {"vkCreateValidationCacheEXT", vkCreateValidationCacheEXT},
6291     {"vkDebugMarkerSetObjectNameEXT", vkDebugMarkerSetObjectNameEXT},
6292     {"vkDebugMarkerSetObjectTagEXT", vkDebugMarkerSetObjectTagEXT},
6293     {"vkDeferredOperationJoinKHR", vkDeferredOperationJoinKHR},
6294     {"vkDestroyAccelerationStructureKHR", vkDestroyAccelerationStructureKHR},
6295     {"vkDestroyAccelerationStructureNV", vkDestroyAccelerationStructureNV},
6296     {"vkDestroyBuffer", vkDestroyBuffer},
6297     {"vkDestroyBufferView", vkDestroyBufferView},
6298     {"vkDestroyCommandPool", vkDestroyCommandPool},
6299     {"vkDestroyCuFunctionNVX", vkDestroyCuFunctionNVX},
6300     {"vkDestroyCuModuleNVX", vkDestroyCuModuleNVX},
6301     {"vkDestroyDeferredOperationKHR", vkDestroyDeferredOperationKHR},
6302     {"vkDestroyDescriptorPool", vkDestroyDescriptorPool},
6303     {"vkDestroyDescriptorSetLayout", vkDestroyDescriptorSetLayout},
6304     {"vkDestroyDescriptorUpdateTemplate", vkDestroyDescriptorUpdateTemplate},
6305     {"vkDestroyDescriptorUpdateTemplateKHR", vkDestroyDescriptorUpdateTemplateKHR},
6306     {"vkDestroyDevice", vkDestroyDevice},
6307     {"vkDestroyEvent", vkDestroyEvent},
6308     {"vkDestroyFence", vkDestroyFence},
6309     {"vkDestroyFramebuffer", vkDestroyFramebuffer},
6310     {"vkDestroyImage", vkDestroyImage},
6311     {"vkDestroyImageView", vkDestroyImageView},
6312     {"vkDestroyIndirectCommandsLayoutNV", vkDestroyIndirectCommandsLayoutNV},
6313     {"vkDestroyMicromapEXT", vkDestroyMicromapEXT},
6314     {"vkDestroyOpticalFlowSessionNV", vkDestroyOpticalFlowSessionNV},
6315     {"vkDestroyPipeline", vkDestroyPipeline},
6316     {"vkDestroyPipelineCache", vkDestroyPipelineCache},
6317     {"vkDestroyPipelineLayout", vkDestroyPipelineLayout},
6318     {"vkDestroyPrivateDataSlot", vkDestroyPrivateDataSlot},
6319     {"vkDestroyPrivateDataSlotEXT", vkDestroyPrivateDataSlotEXT},
6320     {"vkDestroyQueryPool", vkDestroyQueryPool},
6321     {"vkDestroyRenderPass", vkDestroyRenderPass},
6322     {"vkDestroySampler", vkDestroySampler},
6323     {"vkDestroySamplerYcbcrConversion", vkDestroySamplerYcbcrConversion},
6324     {"vkDestroySamplerYcbcrConversionKHR", vkDestroySamplerYcbcrConversionKHR},
6325     {"vkDestroySemaphore", vkDestroySemaphore},
6326     {"vkDestroyShaderEXT", vkDestroyShaderEXT},
6327     {"vkDestroyShaderModule", vkDestroyShaderModule},
6328     {"vkDestroySwapchainKHR", vkDestroySwapchainKHR},
6329     {"vkDestroyValidationCacheEXT", vkDestroyValidationCacheEXT},
6330     {"vkDeviceWaitIdle", vkDeviceWaitIdle},
6331     {"vkEndCommandBuffer", vkEndCommandBuffer},
6332     {"vkFlushMappedMemoryRanges", vkFlushMappedMemoryRanges},
6333     {"vkFreeCommandBuffers", vkFreeCommandBuffers},
6334     {"vkFreeDescriptorSets", vkFreeDescriptorSets},
6335     {"vkFreeMemory", vkFreeMemory},
6336     {"vkGetAccelerationStructureBuildSizesKHR", vkGetAccelerationStructureBuildSizesKHR},
6337     {"vkGetAccelerationStructureDeviceAddressKHR", vkGetAccelerationStructureDeviceAddressKHR},
6338     {"vkGetAccelerationStructureHandleNV", vkGetAccelerationStructureHandleNV},
6339     {"vkGetAccelerationStructureMemoryRequirementsNV", vkGetAccelerationStructureMemoryRequirementsNV},
6340     {"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT", vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT},
6341     {"vkGetBufferDeviceAddress", vkGetBufferDeviceAddress},
6342     {"vkGetBufferDeviceAddressEXT", vkGetBufferDeviceAddressEXT},
6343     {"vkGetBufferDeviceAddressKHR", vkGetBufferDeviceAddressKHR},
6344     {"vkGetBufferMemoryRequirements", vkGetBufferMemoryRequirements},
6345     {"vkGetBufferMemoryRequirements2", vkGetBufferMemoryRequirements2},
6346     {"vkGetBufferMemoryRequirements2KHR", vkGetBufferMemoryRequirements2KHR},
6347     {"vkGetBufferOpaqueCaptureAddress", vkGetBufferOpaqueCaptureAddress},
6348     {"vkGetBufferOpaqueCaptureAddressKHR", vkGetBufferOpaqueCaptureAddressKHR},
6349     {"vkGetBufferOpaqueCaptureDescriptorDataEXT", vkGetBufferOpaqueCaptureDescriptorDataEXT},
6350     {"vkGetCalibratedTimestampsEXT", vkGetCalibratedTimestampsEXT},
6351     {"vkGetDeferredOperationMaxConcurrencyKHR", vkGetDeferredOperationMaxConcurrencyKHR},
6352     {"vkGetDeferredOperationResultKHR", vkGetDeferredOperationResultKHR},
6353     {"vkGetDescriptorEXT", vkGetDescriptorEXT},
6354     {"vkGetDescriptorSetHostMappingVALVE", vkGetDescriptorSetHostMappingVALVE},
6355     {"vkGetDescriptorSetLayoutBindingOffsetEXT", vkGetDescriptorSetLayoutBindingOffsetEXT},
6356     {"vkGetDescriptorSetLayoutHostMappingInfoVALVE", vkGetDescriptorSetLayoutHostMappingInfoVALVE},
6357     {"vkGetDescriptorSetLayoutSizeEXT", vkGetDescriptorSetLayoutSizeEXT},
6358     {"vkGetDescriptorSetLayoutSupport", vkGetDescriptorSetLayoutSupport},
6359     {"vkGetDescriptorSetLayoutSupportKHR", vkGetDescriptorSetLayoutSupportKHR},
6360     {"vkGetDeviceAccelerationStructureCompatibilityKHR", vkGetDeviceAccelerationStructureCompatibilityKHR},
6361     {"vkGetDeviceBufferMemoryRequirements", vkGetDeviceBufferMemoryRequirements},
6362     {"vkGetDeviceBufferMemoryRequirementsKHR", vkGetDeviceBufferMemoryRequirementsKHR},
6363     {"vkGetDeviceFaultInfoEXT", vkGetDeviceFaultInfoEXT},
6364     {"vkGetDeviceGroupPeerMemoryFeatures", vkGetDeviceGroupPeerMemoryFeatures},
6365     {"vkGetDeviceGroupPeerMemoryFeaturesKHR", vkGetDeviceGroupPeerMemoryFeaturesKHR},
6366     {"vkGetDeviceGroupPresentCapabilitiesKHR", vkGetDeviceGroupPresentCapabilitiesKHR},
6367     {"vkGetDeviceGroupSurfacePresentModesKHR", vkGetDeviceGroupSurfacePresentModesKHR},
6368     {"vkGetDeviceImageMemoryRequirements", vkGetDeviceImageMemoryRequirements},
6369     {"vkGetDeviceImageMemoryRequirementsKHR", vkGetDeviceImageMemoryRequirementsKHR},
6370     {"vkGetDeviceImageSparseMemoryRequirements", vkGetDeviceImageSparseMemoryRequirements},
6371     {"vkGetDeviceImageSparseMemoryRequirementsKHR", vkGetDeviceImageSparseMemoryRequirementsKHR},
6372     {"vkGetDeviceImageSubresourceLayoutKHR", vkGetDeviceImageSubresourceLayoutKHR},
6373     {"vkGetDeviceMemoryCommitment", vkGetDeviceMemoryCommitment},
6374     {"vkGetDeviceMemoryOpaqueCaptureAddress", vkGetDeviceMemoryOpaqueCaptureAddress},
6375     {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", vkGetDeviceMemoryOpaqueCaptureAddressKHR},
6376     {"vkGetDeviceMicromapCompatibilityEXT", vkGetDeviceMicromapCompatibilityEXT},
6377     {"vkGetDeviceProcAddr", vkGetDeviceProcAddr},
6378     {"vkGetDeviceQueue", vkGetDeviceQueue},
6379     {"vkGetDeviceQueue2", vkGetDeviceQueue2},
6380     {"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI},
6381     {"vkGetDynamicRenderingTilePropertiesQCOM", vkGetDynamicRenderingTilePropertiesQCOM},
6382     {"vkGetEventStatus", vkGetEventStatus},
6383     {"vkGetFenceStatus", vkGetFenceStatus},
6384     {"vkGetFramebufferTilePropertiesQCOM", vkGetFramebufferTilePropertiesQCOM},
6385     {"vkGetGeneratedCommandsMemoryRequirementsNV", vkGetGeneratedCommandsMemoryRequirementsNV},
6386     {"vkGetImageMemoryRequirements", vkGetImageMemoryRequirements},
6387     {"vkGetImageMemoryRequirements2", vkGetImageMemoryRequirements2},
6388     {"vkGetImageMemoryRequirements2KHR", vkGetImageMemoryRequirements2KHR},
6389     {"vkGetImageOpaqueCaptureDescriptorDataEXT", vkGetImageOpaqueCaptureDescriptorDataEXT},
6390     {"vkGetImageSparseMemoryRequirements", vkGetImageSparseMemoryRequirements},
6391     {"vkGetImageSparseMemoryRequirements2", vkGetImageSparseMemoryRequirements2},
6392     {"vkGetImageSparseMemoryRequirements2KHR", vkGetImageSparseMemoryRequirements2KHR},
6393     {"vkGetImageSubresourceLayout", vkGetImageSubresourceLayout},
6394     {"vkGetImageSubresourceLayout2EXT", vkGetImageSubresourceLayout2EXT},
6395     {"vkGetImageSubresourceLayout2KHR", vkGetImageSubresourceLayout2KHR},
6396     {"vkGetImageViewAddressNVX", vkGetImageViewAddressNVX},
6397     {"vkGetImageViewHandleNVX", vkGetImageViewHandleNVX},
6398     {"vkGetImageViewOpaqueCaptureDescriptorDataEXT", vkGetImageViewOpaqueCaptureDescriptorDataEXT},
6399     {"vkGetLatencyTimingsNV", vkGetLatencyTimingsNV},
6400     {"vkGetMemoryHostPointerPropertiesEXT", vkGetMemoryHostPointerPropertiesEXT},
6401     {"vkGetMicromapBuildSizesEXT", vkGetMicromapBuildSizesEXT},
6402     {"vkGetPerformanceParameterINTEL", vkGetPerformanceParameterINTEL},
6403     {"vkGetPipelineCacheData", vkGetPipelineCacheData},
6404     {"vkGetPipelineExecutableInternalRepresentationsKHR", vkGetPipelineExecutableInternalRepresentationsKHR},
6405     {"vkGetPipelineExecutablePropertiesKHR", vkGetPipelineExecutablePropertiesKHR},
6406     {"vkGetPipelineExecutableStatisticsKHR", vkGetPipelineExecutableStatisticsKHR},
6407     {"vkGetPipelineIndirectDeviceAddressNV", vkGetPipelineIndirectDeviceAddressNV},
6408     {"vkGetPipelineIndirectMemoryRequirementsNV", vkGetPipelineIndirectMemoryRequirementsNV},
6409     {"vkGetPipelinePropertiesEXT", vkGetPipelinePropertiesEXT},
6410     {"vkGetPrivateData", vkGetPrivateData},
6411     {"vkGetPrivateDataEXT", vkGetPrivateDataEXT},
6412     {"vkGetQueryPoolResults", vkGetQueryPoolResults},
6413     {"vkGetQueueCheckpointData2NV", vkGetQueueCheckpointData2NV},
6414     {"vkGetQueueCheckpointDataNV", vkGetQueueCheckpointDataNV},
6415     {"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", vkGetRayTracingCaptureReplayShaderGroupHandlesKHR},
6416     {"vkGetRayTracingShaderGroupHandlesKHR", vkGetRayTracingShaderGroupHandlesKHR},
6417     {"vkGetRayTracingShaderGroupHandlesNV", vkGetRayTracingShaderGroupHandlesNV},
6418     {"vkGetRayTracingShaderGroupStackSizeKHR", vkGetRayTracingShaderGroupStackSizeKHR},
6419     {"vkGetRenderAreaGranularity", vkGetRenderAreaGranularity},
6420     {"vkGetRenderingAreaGranularityKHR", vkGetRenderingAreaGranularityKHR},
6421     {"vkGetSamplerOpaqueCaptureDescriptorDataEXT", vkGetSamplerOpaqueCaptureDescriptorDataEXT},
6422     {"vkGetSemaphoreCounterValue", vkGetSemaphoreCounterValue},
6423     {"vkGetSemaphoreCounterValueKHR", vkGetSemaphoreCounterValueKHR},
6424     {"vkGetShaderBinaryDataEXT", vkGetShaderBinaryDataEXT},
6425     {"vkGetShaderInfoAMD", vkGetShaderInfoAMD},
6426     {"vkGetShaderModuleCreateInfoIdentifierEXT", vkGetShaderModuleCreateInfoIdentifierEXT},
6427     {"vkGetShaderModuleIdentifierEXT", vkGetShaderModuleIdentifierEXT},
6428     {"vkGetSwapchainImagesKHR", vkGetSwapchainImagesKHR},
6429     {"vkGetValidationCacheDataEXT", vkGetValidationCacheDataEXT},
6430     {"vkInitializePerformanceApiINTEL", vkInitializePerformanceApiINTEL},
6431     {"vkInvalidateMappedMemoryRanges", vkInvalidateMappedMemoryRanges},
6432     {"vkLatencySleepNV", vkLatencySleepNV},
6433     {"vkMapMemory", vkMapMemory},
6434     {"vkMapMemory2KHR", vkMapMemory2KHR},
6435     {"vkMergePipelineCaches", vkMergePipelineCaches},
6436     {"vkMergeValidationCachesEXT", vkMergeValidationCachesEXT},
6437     {"vkQueueBeginDebugUtilsLabelEXT", vkQueueBeginDebugUtilsLabelEXT},
6438     {"vkQueueBindSparse", vkQueueBindSparse},
6439     {"vkQueueEndDebugUtilsLabelEXT", vkQueueEndDebugUtilsLabelEXT},
6440     {"vkQueueInsertDebugUtilsLabelEXT", vkQueueInsertDebugUtilsLabelEXT},
6441     {"vkQueueNotifyOutOfBandNV", vkQueueNotifyOutOfBandNV},
6442     {"vkQueuePresentKHR", vkQueuePresentKHR},
6443     {"vkQueueSetPerformanceConfigurationINTEL", vkQueueSetPerformanceConfigurationINTEL},
6444     {"vkQueueSubmit", vkQueueSubmit},
6445     {"vkQueueSubmit2", vkQueueSubmit2},
6446     {"vkQueueSubmit2KHR", vkQueueSubmit2KHR},
6447     {"vkQueueWaitIdle", vkQueueWaitIdle},
6448     {"vkReleasePerformanceConfigurationINTEL", vkReleasePerformanceConfigurationINTEL},
6449     {"vkReleaseProfilingLockKHR", vkReleaseProfilingLockKHR},
6450     {"vkReleaseSwapchainImagesEXT", vkReleaseSwapchainImagesEXT},
6451     {"vkResetCommandBuffer", vkResetCommandBuffer},
6452     {"vkResetCommandPool", vkResetCommandPool},
6453     {"vkResetDescriptorPool", vkResetDescriptorPool},
6454     {"vkResetEvent", vkResetEvent},
6455     {"vkResetFences", vkResetFences},
6456     {"vkResetQueryPool", vkResetQueryPool},
6457     {"vkResetQueryPoolEXT", vkResetQueryPoolEXT},
6458     {"vkSetDebugUtilsObjectNameEXT", vkSetDebugUtilsObjectNameEXT},
6459     {"vkSetDebugUtilsObjectTagEXT", vkSetDebugUtilsObjectTagEXT},
6460     {"vkSetDeviceMemoryPriorityEXT", vkSetDeviceMemoryPriorityEXT},
6461     {"vkSetEvent", vkSetEvent},
6462     {"vkSetHdrMetadataEXT", vkSetHdrMetadataEXT},
6463     {"vkSetLatencyMarkerNV", vkSetLatencyMarkerNV},
6464     {"vkSetLatencySleepModeNV", vkSetLatencySleepModeNV},
6465     {"vkSetPrivateData", vkSetPrivateData},
6466     {"vkSetPrivateDataEXT", vkSetPrivateDataEXT},
6467     {"vkSignalSemaphore", vkSignalSemaphore},
6468     {"vkSignalSemaphoreKHR", vkSignalSemaphoreKHR},
6469     {"vkTransitionImageLayoutEXT", vkTransitionImageLayoutEXT},
6470     {"vkTrimCommandPool", vkTrimCommandPool},
6471     {"vkTrimCommandPoolKHR", vkTrimCommandPoolKHR},
6472     {"vkUninitializePerformanceApiINTEL", vkUninitializePerformanceApiINTEL},
6473     {"vkUnmapMemory", vkUnmapMemory},
6474     {"vkUnmapMemory2KHR", vkUnmapMemory2KHR},
6475     {"vkUpdateDescriptorSetWithTemplate", vkUpdateDescriptorSetWithTemplate},
6476     {"vkUpdateDescriptorSetWithTemplateKHR", vkUpdateDescriptorSetWithTemplateKHR},
6477     {"vkUpdateDescriptorSets", vkUpdateDescriptorSets},
6478     {"vkWaitForFences", vkWaitForFences},
6479     {"vkWaitForPresentKHR", vkWaitForPresentKHR},
6480     {"vkWaitSemaphores", vkWaitSemaphores},
6481     {"vkWaitSemaphoresKHR", vkWaitSemaphoresKHR},
6482     {"vkWriteAccelerationStructuresPropertiesKHR", vkWriteAccelerationStructuresPropertiesKHR},
6483     {"vkWriteMicromapsPropertiesEXT", vkWriteMicromapsPropertiesEXT},
6484 };
6485
6486 static const struct vulkan_func vk_phys_dev_dispatch_table[] =
6487 {
6488     {"vkCreateDevice", vkCreateDevice},
6489     {"vkEnumerateDeviceExtensionProperties", vkEnumerateDeviceExtensionProperties},
6490     {"vkEnumerateDeviceLayerProperties", vkEnumerateDeviceLayerProperties},
6491     {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
6492     {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", vkGetPhysicalDeviceCalibrateableTimeDomainsEXT},
6493     {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR},
6494     {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", vkGetPhysicalDeviceCooperativeMatrixPropertiesNV},
6495     {"vkGetPhysicalDeviceExternalBufferProperties", vkGetPhysicalDeviceExternalBufferProperties},
6496     {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", vkGetPhysicalDeviceExternalBufferPropertiesKHR},
6497     {"vkGetPhysicalDeviceExternalFenceProperties", vkGetPhysicalDeviceExternalFenceProperties},
6498     {"vkGetPhysicalDeviceExternalFencePropertiesKHR", vkGetPhysicalDeviceExternalFencePropertiesKHR},
6499     {"vkGetPhysicalDeviceExternalSemaphoreProperties", vkGetPhysicalDeviceExternalSemaphoreProperties},
6500     {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", vkGetPhysicalDeviceExternalSemaphorePropertiesKHR},
6501     {"vkGetPhysicalDeviceFeatures", vkGetPhysicalDeviceFeatures},
6502     {"vkGetPhysicalDeviceFeatures2", vkGetPhysicalDeviceFeatures2},
6503     {"vkGetPhysicalDeviceFeatures2KHR", vkGetPhysicalDeviceFeatures2KHR},
6504     {"vkGetPhysicalDeviceFormatProperties", vkGetPhysicalDeviceFormatProperties},
6505     {"vkGetPhysicalDeviceFormatProperties2", vkGetPhysicalDeviceFormatProperties2},
6506     {"vkGetPhysicalDeviceFormatProperties2KHR", vkGetPhysicalDeviceFormatProperties2KHR},
6507     {"vkGetPhysicalDeviceFragmentShadingRatesKHR", vkGetPhysicalDeviceFragmentShadingRatesKHR},
6508     {"vkGetPhysicalDeviceImageFormatProperties", vkGetPhysicalDeviceImageFormatProperties},
6509     {"vkGetPhysicalDeviceImageFormatProperties2", vkGetPhysicalDeviceImageFormatProperties2},
6510     {"vkGetPhysicalDeviceImageFormatProperties2KHR", vkGetPhysicalDeviceImageFormatProperties2KHR},
6511     {"vkGetPhysicalDeviceMemoryProperties", vkGetPhysicalDeviceMemoryProperties},
6512     {"vkGetPhysicalDeviceMemoryProperties2", vkGetPhysicalDeviceMemoryProperties2},
6513     {"vkGetPhysicalDeviceMemoryProperties2KHR", vkGetPhysicalDeviceMemoryProperties2KHR},
6514     {"vkGetPhysicalDeviceMultisamplePropertiesEXT", vkGetPhysicalDeviceMultisamplePropertiesEXT},
6515     {"vkGetPhysicalDeviceOpticalFlowImageFormatsNV", vkGetPhysicalDeviceOpticalFlowImageFormatsNV},
6516     {"vkGetPhysicalDevicePresentRectanglesKHR", vkGetPhysicalDevicePresentRectanglesKHR},
6517     {"vkGetPhysicalDeviceProperties", vkGetPhysicalDeviceProperties},
6518     {"vkGetPhysicalDeviceProperties2", vkGetPhysicalDeviceProperties2},
6519     {"vkGetPhysicalDeviceProperties2KHR", vkGetPhysicalDeviceProperties2KHR},
6520     {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
6521     {"vkGetPhysicalDeviceQueueFamilyProperties", vkGetPhysicalDeviceQueueFamilyProperties},
6522     {"vkGetPhysicalDeviceQueueFamilyProperties2", vkGetPhysicalDeviceQueueFamilyProperties2},
6523     {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", vkGetPhysicalDeviceQueueFamilyProperties2KHR},
6524     {"vkGetPhysicalDeviceSparseImageFormatProperties", vkGetPhysicalDeviceSparseImageFormatProperties},
6525     {"vkGetPhysicalDeviceSparseImageFormatProperties2", vkGetPhysicalDeviceSparseImageFormatProperties2},
6526     {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", vkGetPhysicalDeviceSparseImageFormatProperties2KHR},
6527     {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
6528     {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", vkGetPhysicalDeviceSurfaceCapabilities2KHR},
6529     {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", vkGetPhysicalDeviceSurfaceCapabilitiesKHR},
6530     {"vkGetPhysicalDeviceSurfaceFormats2KHR", vkGetPhysicalDeviceSurfaceFormats2KHR},
6531     {"vkGetPhysicalDeviceSurfaceFormatsKHR", vkGetPhysicalDeviceSurfaceFormatsKHR},
6532     {"vkGetPhysicalDeviceSurfacePresentModesKHR", vkGetPhysicalDeviceSurfacePresentModesKHR},
6533     {"vkGetPhysicalDeviceSurfaceSupportKHR", vkGetPhysicalDeviceSurfaceSupportKHR},
6534     {"vkGetPhysicalDeviceToolProperties", vkGetPhysicalDeviceToolProperties},
6535     {"vkGetPhysicalDeviceToolPropertiesEXT", vkGetPhysicalDeviceToolPropertiesEXT},
6536     {"vkGetPhysicalDeviceWin32PresentationSupportKHR", vkGetPhysicalDeviceWin32PresentationSupportKHR},
6537 };
6538
6539 static const struct vulkan_func vk_instance_dispatch_table[] =
6540 {
6541     {"vkCreateDebugReportCallbackEXT", vkCreateDebugReportCallbackEXT},
6542     {"vkCreateDebugUtilsMessengerEXT", vkCreateDebugUtilsMessengerEXT},
6543     {"vkCreateWin32SurfaceKHR", vkCreateWin32SurfaceKHR},
6544     {"vkDebugReportMessageEXT", vkDebugReportMessageEXT},
6545     {"vkDestroyDebugReportCallbackEXT", vkDestroyDebugReportCallbackEXT},
6546     {"vkDestroyDebugUtilsMessengerEXT", vkDestroyDebugUtilsMessengerEXT},
6547     {"vkDestroyInstance", vkDestroyInstance},
6548     {"vkDestroySurfaceKHR", vkDestroySurfaceKHR},
6549     {"vkEnumeratePhysicalDeviceGroups", vkEnumeratePhysicalDeviceGroups},
6550     {"vkEnumeratePhysicalDeviceGroupsKHR", vkEnumeratePhysicalDeviceGroupsKHR},
6551     {"vkEnumeratePhysicalDevices", vkEnumeratePhysicalDevices},
6552     {"vkSubmitDebugUtilsMessageEXT", vkSubmitDebugUtilsMessageEXT},
6553 };
6554
6555 void *wine_vk_get_device_proc_addr(const char *name)
6556 {
6557     unsigned int i;
6558     for (i = 0; i < ARRAY_SIZE(vk_device_dispatch_table); i++)
6559     {
6560         if (strcmp(vk_device_dispatch_table[i].name, name) == 0)
6561         {
6562             TRACE("Found name=%s in device table\n", debugstr_a(name));
6563             return vk_device_dispatch_table[i].func;
6564         }
6565     }
6566     return NULL;
6567 }
6568
6569 void *wine_vk_get_phys_dev_proc_addr(const char *name)
6570 {
6571     unsigned int i;
6572     for (i = 0; i < ARRAY_SIZE(vk_phys_dev_dispatch_table); i++)
6573     {
6574         if (strcmp(vk_phys_dev_dispatch_table[i].name, name) == 0)
6575         {
6576             TRACE("Found name=%s in physical device table\n", debugstr_a(name));
6577             return vk_phys_dev_dispatch_table[i].func;
6578         }
6579     }
6580     return NULL;
6581 }
6582
6583 void *wine_vk_get_instance_proc_addr(const char *name)
6584 {
6585     unsigned int i;
6586     for (i = 0; i < ARRAY_SIZE(vk_instance_dispatch_table); i++)
6587     {
6588         if (strcmp(vk_instance_dispatch_table[i].name, name) == 0)
6589         {
6590             TRACE("Found name=%s in instance table\n", debugstr_a(name));
6591             return vk_instance_dispatch_table[i].func;
6592         }
6593     }
6594     return NULL;
6595 }