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