dlls/winevulkan/vulkan_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-2021 The Khronos Group Inc.
   7  *
   8  * SPDX-License-Identifier: Apache-2.0 OR MIT
   9  *
  10  */
  11
  12 #if 0
  13 #pragma makedep unix
  14 #endif
  15
  16 #include "config.h"
  17 #include "wine/port.h"
  18
  19 #include "vulkan_private.h"
  20
  21 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  22
  23 #if defined(USE_STRUCT_CONVERSION)
  24 static inline void convert_VkAcquireNextImageInfoKHR_win_to_host(const VkAcquireNextImageInfoKHR *in, VkAcquireNextImageInfoKHR_host *out)
  25 {
  26     if (!in) return;
  27
  28     out->sType = in->sType;
  29     out->pNext = in->pNext;
  30     out->swapchain = in->swapchain;
  31     out->timeout = in->timeout;
  32     out->semaphore = in->semaphore;
  33     out->fence = in->fence;
  34     out->deviceMask = in->deviceMask;
  35 }
  36 #endif /* USE_STRUCT_CONVERSION */
  37
  38 #if defined(USE_STRUCT_CONVERSION)
  39 static inline void convert_VkAcquireProfilingLockInfoKHR_win_to_host(const VkAcquireProfilingLockInfoKHR *in, VkAcquireProfilingLockInfoKHR_host *out)
  40 {
  41     if (!in) return;
  42
  43     out->sType = in->sType;
  44     out->pNext = in->pNext;
  45     out->flags = in->flags;
  46     out->timeout = in->timeout;
  47 }
  48 #endif /* USE_STRUCT_CONVERSION */
  49
  50 #if defined(USE_STRUCT_CONVERSION)
  51 static inline void convert_VkDescriptorSetAllocateInfo_win_to_host(const VkDescriptorSetAllocateInfo *in, VkDescriptorSetAllocateInfo_host *out)
  52 {
  53     if (!in) return;
  54
  55     out->sType = in->sType;
  56     out->pNext = in->pNext;
  57     out->descriptorPool = in->descriptorPool;
  58     out->descriptorSetCount = in->descriptorSetCount;
  59     out->pSetLayouts = in->pSetLayouts;
  60 }
  61 #endif /* USE_STRUCT_CONVERSION */
  62
  63 #if defined(USE_STRUCT_CONVERSION)
  64 static inline void convert_VkMemoryAllocateInfo_win_to_host(const VkMemoryAllocateInfo *in, VkMemoryAllocateInfo_host *out)
  65 {
  66     if (!in) return;
  67
  68     out->sType = in->sType;
  69     out->pNext = in->pNext;
  70     out->allocationSize = in->allocationSize;
  71     out->memoryTypeIndex = in->memoryTypeIndex;
  72 }
  73 #endif /* USE_STRUCT_CONVERSION */
  74
  75 #if defined(USE_STRUCT_CONVERSION)
  76 static inline VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo_array_win_to_host(const VkCommandBufferInheritanceInfo *in, uint32_t count)
  77 {
  78     VkCommandBufferInheritanceInfo_host *out;
  79     unsigned int i;
  80
  81     if (!in) return NULL;
  82
  83     out = malloc(count * sizeof(*out));
  84     for (i = 0; i < count; i++)
  85     {
  86         out[i].sType = in[i].sType;
  87         out[i].pNext = in[i].pNext;
  88         out[i].renderPass = in[i].renderPass;
  89         out[i].subpass = in[i].subpass;
  90         out[i].framebuffer = in[i].framebuffer;
  91         out[i].occlusionQueryEnable = in[i].occlusionQueryEnable;
  92         out[i].queryFlags = in[i].queryFlags;
  93         out[i].pipelineStatistics = in[i].pipelineStatistics;
  94     }
  95
  96     return out;
  97 }
  98 #endif /* USE_STRUCT_CONVERSION */
  99
 100 #if defined(USE_STRUCT_CONVERSION)
 101 static inline void free_VkCommandBufferInheritanceInfo_array(VkCommandBufferInheritanceInfo_host *in, uint32_t count)
 102 {
 103     if (!in) return;
 104
 105     free(in);
 106 }
 107 #endif /* USE_STRUCT_CONVERSION */
 108
 109 #if defined(USE_STRUCT_CONVERSION)
 110 static inline void convert_VkCommandBufferBeginInfo_win_to_host(const VkCommandBufferBeginInfo *in, VkCommandBufferBeginInfo_host *out)
 111 {
 112     if (!in) return;
 113
 114     out->sType = in->sType;
 115     out->pNext = in->pNext;
 116     out->flags = in->flags;
 117     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win_to_host(in->pInheritanceInfo, 1);
 118 }
 119 #endif /* USE_STRUCT_CONVERSION */
 120
 121 #if defined(USE_STRUCT_CONVERSION)
 122 static inline void free_VkCommandBufferBeginInfo(VkCommandBufferBeginInfo_host *in)
 123 {
 124     free_VkCommandBufferInheritanceInfo_array((VkCommandBufferInheritanceInfo_host *)in->pInheritanceInfo, 1);
 125 }
 126 #endif /* USE_STRUCT_CONVERSION */
 127
 128 #if defined(USE_STRUCT_CONVERSION)
 129 static inline VkBindAccelerationStructureMemoryInfoNV_host *convert_VkBindAccelerationStructureMemoryInfoNV_array_win_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count)
 130 {
 131     VkBindAccelerationStructureMemoryInfoNV_host *out;
 132     unsigned int i;
 133
 134     if (!in) return NULL;
 135
 136     out = malloc(count * sizeof(*out));
 137     for (i = 0; i < count; i++)
 138     {
 139         out[i].sType = in[i].sType;
 140         out[i].pNext = in[i].pNext;
 141         out[i].accelerationStructure = in[i].accelerationStructure;
 142         out[i].memory = in[i].memory;
 143         out[i].memoryOffset = in[i].memoryOffset;
 144         out[i].deviceIndexCount = in[i].deviceIndexCount;
 145         out[i].pDeviceIndices = in[i].pDeviceIndices;
 146     }
 147
 148     return out;
 149 }
 150 #endif /* USE_STRUCT_CONVERSION */
 151
 152 #if defined(USE_STRUCT_CONVERSION)
 153 static inline void free_VkBindAccelerationStructureMemoryInfoNV_array(VkBindAccelerationStructureMemoryInfoNV_host *in, uint32_t count)
 154 {
 155     if (!in) return;
 156
 157     free(in);
 158 }
 159 #endif /* USE_STRUCT_CONVERSION */
 160
 161 #if defined(USE_STRUCT_CONVERSION)
 162 static inline VkBindBufferMemoryInfo_host *convert_VkBindBufferMemoryInfo_array_win_to_host(const VkBindBufferMemoryInfo *in, uint32_t count)
 163 {
 164     VkBindBufferMemoryInfo_host *out;
 165     unsigned int i;
 166
 167     if (!in) return NULL;
 168
 169     out = malloc(count * sizeof(*out));
 170     for (i = 0; i < count; i++)
 171     {
 172         out[i].sType = in[i].sType;
 173         out[i].pNext = in[i].pNext;
 174         out[i].buffer = in[i].buffer;
 175         out[i].memory = in[i].memory;
 176         out[i].memoryOffset = in[i].memoryOffset;
 177     }
 178
 179     return out;
 180 }
 181 #endif /* USE_STRUCT_CONVERSION */
 182
 183 #if defined(USE_STRUCT_CONVERSION)
 184 static inline void free_VkBindBufferMemoryInfo_array(VkBindBufferMemoryInfo_host *in, uint32_t count)
 185 {
 186     if (!in) return;
 187
 188     free(in);
 189 }
 190 #endif /* USE_STRUCT_CONVERSION */
 191
 192 #if defined(USE_STRUCT_CONVERSION)
 193 static inline VkBindImageMemoryInfo_host *convert_VkBindImageMemoryInfo_array_win_to_host(const VkBindImageMemoryInfo *in, uint32_t count)
 194 {
 195     VkBindImageMemoryInfo_host *out;
 196     unsigned int i;
 197
 198     if (!in) return NULL;
 199
 200     out = malloc(count * sizeof(*out));
 201     for (i = 0; i < count; i++)
 202     {
 203         out[i].sType = in[i].sType;
 204         out[i].pNext = in[i].pNext;
 205         out[i].image = in[i].image;
 206         out[i].memory = in[i].memory;
 207         out[i].memoryOffset = in[i].memoryOffset;
 208     }
 209
 210     return out;
 211 }
 212 #endif /* USE_STRUCT_CONVERSION */
 213
 214 #if defined(USE_STRUCT_CONVERSION)
 215 static inline void free_VkBindImageMemoryInfo_array(VkBindImageMemoryInfo_host *in, uint32_t count)
 216 {
 217     if (!in) return;
 218
 219     free(in);
 220 }
 221 #endif /* USE_STRUCT_CONVERSION */
 222
 223 #if defined(USE_STRUCT_CONVERSION)
 224 static inline VkAccelerationStructureBuildGeometryInfoKHR_host *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win_to_host(const VkAccelerationStructureBuildGeometryInfoKHR *in, uint32_t count)
 225 {
 226     VkAccelerationStructureBuildGeometryInfoKHR_host *out;
 227     unsigned int i;
 228
 229     if (!in) return NULL;
 230
 231     out = malloc(count * sizeof(*out));
 232     for (i = 0; i < count; i++)
 233     {
 234         out[i].sType = in[i].sType;
 235         out[i].pNext = in[i].pNext;
 236         out[i].type = in[i].type;
 237         out[i].flags = in[i].flags;
 238         out[i].mode = in[i].mode;
 239         out[i].srcAccelerationStructure = in[i].srcAccelerationStructure;
 240         out[i].dstAccelerationStructure = in[i].dstAccelerationStructure;
 241         out[i].geometryCount = in[i].geometryCount;
 242         out[i].pGeometries = in[i].pGeometries;
 243         out[i].ppGeometries = in[i].ppGeometries;
 244         out[i].scratchData = in[i].scratchData;
 245     }
 246
 247     return out;
 248 }
 249 #endif /* USE_STRUCT_CONVERSION */
 250
 251 #if defined(USE_STRUCT_CONVERSION)
 252 static inline void free_VkAccelerationStructureBuildGeometryInfoKHR_array(VkAccelerationStructureBuildGeometryInfoKHR_host *in, uint32_t count)
 253 {
 254     if (!in) return;
 255
 256     free(in);
 257 }
 258 #endif /* USE_STRUCT_CONVERSION */
 259
 260 #if defined(USE_STRUCT_CONVERSION)
 261 static inline void convert_VkConditionalRenderingBeginInfoEXT_win_to_host(const VkConditionalRenderingBeginInfoEXT *in, VkConditionalRenderingBeginInfoEXT_host *out)
 262 {
 263     if (!in) return;
 264
 265     out->sType = in->sType;
 266     out->pNext = in->pNext;
 267     out->buffer = in->buffer;
 268     out->offset = in->offset;
 269     out->flags = in->flags;
 270 }
 271 #endif /* USE_STRUCT_CONVERSION */
 272
 273 #if defined(USE_STRUCT_CONVERSION)
 274 static inline void convert_VkRenderPassBeginInfo_win_to_host(const VkRenderPassBeginInfo *in, VkRenderPassBeginInfo_host *out)
 275 {
 276     if (!in) return;
 277
 278     out->sType = in->sType;
 279     out->pNext = in->pNext;
 280     out->renderPass = in->renderPass;
 281     out->framebuffer = in->framebuffer;
 282     out->renderArea = in->renderArea;
 283     out->clearValueCount = in->clearValueCount;
 284     out->pClearValues = in->pClearValues;
 285 }
 286 #endif /* USE_STRUCT_CONVERSION */
 287
 288 #if defined(USE_STRUCT_CONVERSION)
 289 static inline void convert_VkBlitImageInfo2KHR_win_to_host(const VkBlitImageInfo2KHR *in, VkBlitImageInfo2KHR_host *out)
 290 {
 291     if (!in) return;
 292
 293     out->sType = in->sType;
 294     out->pNext = in->pNext;
 295     out->srcImage = in->srcImage;
 296     out->srcImageLayout = in->srcImageLayout;
 297     out->dstImage = in->dstImage;
 298     out->dstImageLayout = in->dstImageLayout;
 299     out->regionCount = in->regionCount;
 300     out->pRegions = in->pRegions;
 301     out->filter = in->filter;
 302 }
 303 #endif /* USE_STRUCT_CONVERSION */
 304
 305 #if defined(USE_STRUCT_CONVERSION)
 306 static inline void convert_VkGeometryTrianglesNV_win_to_host(const VkGeometryTrianglesNV *in, VkGeometryTrianglesNV_host *out)
 307 {
 308     if (!in) return;
 309
 310     out->sType = in->sType;
 311     out->pNext = in->pNext;
 312     out->vertexData = in->vertexData;
 313     out->vertexOffset = in->vertexOffset;
 314     out->vertexCount = in->vertexCount;
 315     out->vertexStride = in->vertexStride;
 316     out->vertexFormat = in->vertexFormat;
 317     out->indexData = in->indexData;
 318     out->indexOffset = in->indexOffset;
 319     out->indexCount = in->indexCount;
 320     out->indexType = in->indexType;
 321     out->transformData = in->transformData;
 322     out->transformOffset = in->transformOffset;
 323 }
 324 #endif /* USE_STRUCT_CONVERSION */
 325
 326 #if defined(USE_STRUCT_CONVERSION)
 327 static inline void convert_VkGeometryAABBNV_win_to_host(const VkGeometryAABBNV *in, VkGeometryAABBNV_host *out)
 328 {
 329     if (!in) return;
 330
 331     out->sType = in->sType;
 332     out->pNext = in->pNext;
 333     out->aabbData = in->aabbData;
 334     out->numAABBs = in->numAABBs;
 335     out->stride = in->stride;
 336     out->offset = in->offset;
 337 }
 338 #endif /* USE_STRUCT_CONVERSION */
 339
 340 #if defined(USE_STRUCT_CONVERSION)
 341 static inline void convert_VkGeometryDataNV_win_to_host(const VkGeometryDataNV *in, VkGeometryDataNV_host *out)
 342 {
 343     if (!in) return;
 344
 345     convert_VkGeometryTrianglesNV_win_to_host(&in->triangles, &out->triangles);
 346     convert_VkGeometryAABBNV_win_to_host(&in->aabbs, &out->aabbs);
 347 }
 348 #endif /* USE_STRUCT_CONVERSION */
 349
 350 #if defined(USE_STRUCT_CONVERSION)
 351 static inline VkGeometryNV_host *convert_VkGeometryNV_array_win_to_host(const VkGeometryNV *in, uint32_t count)
 352 {
 353     VkGeometryNV_host *out;
 354     unsigned int i;
 355
 356     if (!in) return NULL;
 357
 358     out = malloc(count * sizeof(*out));
 359     for (i = 0; i < count; i++)
 360     {
 361         out[i].sType = in[i].sType;
 362         out[i].pNext = in[i].pNext;
 363         out[i].geometryType = in[i].geometryType;
 364         convert_VkGeometryDataNV_win_to_host(&in[i].geometry, &out[i].geometry);
 365         out[i].flags = in[i].flags;
 366     }
 367
 368     return out;
 369 }
 370 #endif /* USE_STRUCT_CONVERSION */
 371
 372 #if defined(USE_STRUCT_CONVERSION)
 373 static inline void free_VkGeometryNV_array(VkGeometryNV_host *in, uint32_t count)
 374 {
 375     if (!in) return;
 376
 377     free(in);
 378 }
 379 #endif /* USE_STRUCT_CONVERSION */
 380
 381 #if defined(USE_STRUCT_CONVERSION)
 382 static inline void convert_VkAccelerationStructureInfoNV_win_to_host(const VkAccelerationStructureInfoNV *in, VkAccelerationStructureInfoNV_host *out)
 383 {
 384     if (!in) return;
 385
 386     out->sType = in->sType;
 387     out->pNext = in->pNext;
 388     out->type = in->type;
 389     out->flags = in->flags;
 390     out->instanceCount = in->instanceCount;
 391     out->geometryCount = in->geometryCount;
 392     out->pGeometries = convert_VkGeometryNV_array_win_to_host(in->pGeometries, in->geometryCount);
 393 }
 394 #endif /* USE_STRUCT_CONVERSION */
 395
 396 #if defined(USE_STRUCT_CONVERSION)
 397 static inline void free_VkAccelerationStructureInfoNV(VkAccelerationStructureInfoNV_host *in)
 398 {
 399     free_VkGeometryNV_array((VkGeometryNV_host *)in->pGeometries, in->geometryCount);
 400 }
 401 #endif /* USE_STRUCT_CONVERSION */
 402
 403 #if defined(USE_STRUCT_CONVERSION)
 404 static inline void convert_VkCopyAccelerationStructureInfoKHR_win_to_host(const VkCopyAccelerationStructureInfoKHR *in, VkCopyAccelerationStructureInfoKHR_host *out)
 405 {
 406     if (!in) return;
 407
 408     out->sType = in->sType;
 409     out->pNext = in->pNext;
 410     out->src = in->src;
 411     out->dst = in->dst;
 412     out->mode = in->mode;
 413 }
 414 #endif /* USE_STRUCT_CONVERSION */
 415
 416 #if defined(USE_STRUCT_CONVERSION)
 417 static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR *in, VkCopyAccelerationStructureToMemoryInfoKHR_host *out)
 418 {
 419     if (!in) return;
 420
 421     out->sType = in->sType;
 422     out->pNext = in->pNext;
 423     out->src = in->src;
 424     out->dst = in->dst;
 425     out->mode = in->mode;
 426 }
 427 #endif /* USE_STRUCT_CONVERSION */
 428
 429 #if defined(USE_STRUCT_CONVERSION)
 430 static inline VkBufferCopy_host *convert_VkBufferCopy_array_win_to_host(const VkBufferCopy *in, uint32_t count)
 431 {
 432     VkBufferCopy_host *out;
 433     unsigned int i;
 434
 435     if (!in) return NULL;
 436
 437     out = malloc(count * sizeof(*out));
 438     for (i = 0; i < count; i++)
 439     {
 440         out[i].srcOffset = in[i].srcOffset;
 441         out[i].dstOffset = in[i].dstOffset;
 442         out[i].size = in[i].size;
 443     }
 444
 445     return out;
 446 }
 447 #endif /* USE_STRUCT_CONVERSION */
 448
 449 #if defined(USE_STRUCT_CONVERSION)
 450 static inline void free_VkBufferCopy_array(VkBufferCopy_host *in, uint32_t count)
 451 {
 452     if (!in) return;
 453
 454     free(in);
 455 }
 456 #endif /* USE_STRUCT_CONVERSION */
 457
 458 #if defined(USE_STRUCT_CONVERSION)
 459 static inline VkBufferCopy2KHR_host *convert_VkBufferCopy2KHR_array_win_to_host(const VkBufferCopy2KHR *in, uint32_t count)
 460 {
 461     VkBufferCopy2KHR_host *out;
 462     unsigned int i;
 463
 464     if (!in) return NULL;
 465
 466     out = malloc(count * sizeof(*out));
 467     for (i = 0; i < count; i++)
 468     {
 469         out[i].sType = in[i].sType;
 470         out[i].pNext = in[i].pNext;
 471         out[i].srcOffset = in[i].srcOffset;
 472         out[i].dstOffset = in[i].dstOffset;
 473         out[i].size = in[i].size;
 474     }
 475
 476     return out;
 477 }
 478 #endif /* USE_STRUCT_CONVERSION */
 479
 480 #if defined(USE_STRUCT_CONVERSION)
 481 static inline void free_VkBufferCopy2KHR_array(VkBufferCopy2KHR_host *in, uint32_t count)
 482 {
 483     if (!in) return;
 484
 485     free(in);
 486 }
 487 #endif /* USE_STRUCT_CONVERSION */
 488
 489 #if defined(USE_STRUCT_CONVERSION)
 490 static inline void convert_VkCopyBufferInfo2KHR_win_to_host(const VkCopyBufferInfo2KHR *in, VkCopyBufferInfo2KHR_host *out)
 491 {
 492     if (!in) return;
 493
 494     out->sType = in->sType;
 495     out->pNext = in->pNext;
 496     out->srcBuffer = in->srcBuffer;
 497     out->dstBuffer = in->dstBuffer;
 498     out->regionCount = in->regionCount;
 499     out->pRegions = convert_VkBufferCopy2KHR_array_win_to_host(in->pRegions, in->regionCount);
 500 }
 501 #endif /* USE_STRUCT_CONVERSION */
 502
 503 #if defined(USE_STRUCT_CONVERSION)
 504 static inline void free_VkCopyBufferInfo2KHR(VkCopyBufferInfo2KHR_host *in)
 505 {
 506     free_VkBufferCopy2KHR_array((VkBufferCopy2KHR_host *)in->pRegions, in->regionCount);
 507 }
 508 #endif /* USE_STRUCT_CONVERSION */
 509
 510 #if defined(USE_STRUCT_CONVERSION)
 511 static inline VkBufferImageCopy_host *convert_VkBufferImageCopy_array_win_to_host(const VkBufferImageCopy *in, uint32_t count)
 512 {
 513     VkBufferImageCopy_host *out;
 514     unsigned int i;
 515
 516     if (!in) return NULL;
 517
 518     out = malloc(count * sizeof(*out));
 519     for (i = 0; i < count; i++)
 520     {
 521         out[i].bufferOffset = in[i].bufferOffset;
 522         out[i].bufferRowLength = in[i].bufferRowLength;
 523         out[i].bufferImageHeight = in[i].bufferImageHeight;
 524         out[i].imageSubresource = in[i].imageSubresource;
 525         out[i].imageOffset = in[i].imageOffset;
 526         out[i].imageExtent = in[i].imageExtent;
 527     }
 528
 529     return out;
 530 }
 531 #endif /* USE_STRUCT_CONVERSION */
 532
 533 #if defined(USE_STRUCT_CONVERSION)
 534 static inline void free_VkBufferImageCopy_array(VkBufferImageCopy_host *in, uint32_t count)
 535 {
 536     if (!in) return;
 537
 538     free(in);
 539 }
 540 #endif /* USE_STRUCT_CONVERSION */
 541
 542 #if defined(USE_STRUCT_CONVERSION)
 543 static inline VkBufferImageCopy2KHR_host *convert_VkBufferImageCopy2KHR_array_win_to_host(const VkBufferImageCopy2KHR *in, uint32_t count)
 544 {
 545     VkBufferImageCopy2KHR_host *out;
 546     unsigned int i;
 547
 548     if (!in) return NULL;
 549
 550     out = malloc(count * sizeof(*out));
 551     for (i = 0; i < count; i++)
 552     {
 553         out[i].sType = in[i].sType;
 554         out[i].pNext = in[i].pNext;
 555         out[i].bufferOffset = in[i].bufferOffset;
 556         out[i].bufferRowLength = in[i].bufferRowLength;
 557         out[i].bufferImageHeight = in[i].bufferImageHeight;
 558         out[i].imageSubresource = in[i].imageSubresource;
 559         out[i].imageOffset = in[i].imageOffset;
 560         out[i].imageExtent = in[i].imageExtent;
 561     }
 562
 563     return out;
 564 }
 565 #endif /* USE_STRUCT_CONVERSION */
 566
 567 #if defined(USE_STRUCT_CONVERSION)
 568 static inline void free_VkBufferImageCopy2KHR_array(VkBufferImageCopy2KHR_host *in, uint32_t count)
 569 {
 570     if (!in) return;
 571
 572     free(in);
 573 }
 574 #endif /* USE_STRUCT_CONVERSION */
 575
 576 #if defined(USE_STRUCT_CONVERSION)
 577 static inline void convert_VkCopyBufferToImageInfo2KHR_win_to_host(const VkCopyBufferToImageInfo2KHR *in, VkCopyBufferToImageInfo2KHR_host *out)
 578 {
 579     if (!in) return;
 580
 581     out->sType = in->sType;
 582     out->pNext = in->pNext;
 583     out->srcBuffer = in->srcBuffer;
 584     out->dstImage = in->dstImage;
 585     out->dstImageLayout = in->dstImageLayout;
 586     out->regionCount = in->regionCount;
 587     out->pRegions = convert_VkBufferImageCopy2KHR_array_win_to_host(in->pRegions, in->regionCount);
 588 }
 589 #endif /* USE_STRUCT_CONVERSION */
 590
 591 #if defined(USE_STRUCT_CONVERSION)
 592 static inline void free_VkCopyBufferToImageInfo2KHR(VkCopyBufferToImageInfo2KHR_host *in)
 593 {
 594     free_VkBufferImageCopy2KHR_array((VkBufferImageCopy2KHR_host *)in->pRegions, in->regionCount);
 595 }
 596 #endif /* USE_STRUCT_CONVERSION */
 597
 598 #if defined(USE_STRUCT_CONVERSION)
 599 static inline void convert_VkCopyImageInfo2KHR_win_to_host(const VkCopyImageInfo2KHR *in, VkCopyImageInfo2KHR_host *out)
 600 {
 601     if (!in) return;
 602
 603     out->sType = in->sType;
 604     out->pNext = in->pNext;
 605     out->srcImage = in->srcImage;
 606     out->srcImageLayout = in->srcImageLayout;
 607     out->dstImage = in->dstImage;
 608     out->dstImageLayout = in->dstImageLayout;
 609     out->regionCount = in->regionCount;
 610     out->pRegions = in->pRegions;
 611 }
 612 #endif /* USE_STRUCT_CONVERSION */
 613
 614 #if defined(USE_STRUCT_CONVERSION)
 615 static inline void convert_VkCopyImageToBufferInfo2KHR_win_to_host(const VkCopyImageToBufferInfo2KHR *in, VkCopyImageToBufferInfo2KHR_host *out)
 616 {
 617     if (!in) return;
 618
 619     out->sType = in->sType;
 620     out->pNext = in->pNext;
 621     out->srcImage = in->srcImage;
 622     out->srcImageLayout = in->srcImageLayout;
 623     out->dstBuffer = in->dstBuffer;
 624     out->regionCount = in->regionCount;
 625     out->pRegions = convert_VkBufferImageCopy2KHR_array_win_to_host(in->pRegions, in->regionCount);
 626 }
 627 #endif /* USE_STRUCT_CONVERSION */
 628
 629 #if defined(USE_STRUCT_CONVERSION)
 630 static inline void free_VkCopyImageToBufferInfo2KHR(VkCopyImageToBufferInfo2KHR_host *in)
 631 {
 632     free_VkBufferImageCopy2KHR_array((VkBufferImageCopy2KHR_host *)in->pRegions, in->regionCount);
 633 }
 634 #endif /* USE_STRUCT_CONVERSION */
 635
 636 #if defined(USE_STRUCT_CONVERSION)
 637 static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR *in, VkCopyMemoryToAccelerationStructureInfoKHR_host *out)
 638 {
 639     if (!in) return;
 640
 641     out->sType = in->sType;
 642     out->pNext = in->pNext;
 643     out->src = in->src;
 644     out->dst = in->dst;
 645     out->mode = in->mode;
 646 }
 647 #endif /* USE_STRUCT_CONVERSION */
 648
 649 #if defined(USE_STRUCT_CONVERSION)
 650 static inline void convert_VkCuLaunchInfoNVX_win_to_host(const VkCuLaunchInfoNVX *in, VkCuLaunchInfoNVX_host *out)
 651 {
 652     if (!in) return;
 653
 654     out->sType = in->sType;
 655     out->pNext = in->pNext;
 656     out->function = in->function;
 657     out->gridDimX = in->gridDimX;
 658     out->gridDimY = in->gridDimY;
 659     out->gridDimZ = in->gridDimZ;
 660     out->blockDimX = in->blockDimX;
 661     out->blockDimY = in->blockDimY;
 662     out->blockDimZ = in->blockDimZ;
 663     out->sharedMemBytes = in->sharedMemBytes;
 664     out->paramCount = in->paramCount;
 665     out->pParams = in->pParams;
 666     out->extraCount = in->extraCount;
 667     out->pExtras = in->pExtras;
 668 }
 669 #endif /* USE_STRUCT_CONVERSION */
 670
 671 static inline VkCommandBuffer *convert_VkCommandBuffer_array_win_to_host(const VkCommandBuffer *in, uint32_t count)
 672 {
 673     VkCommandBuffer *out;
 674     unsigned int i;
 675
 676     if (!in) return NULL;
 677
 678     out = malloc(count * sizeof(*out));
 679     for (i = 0; i < count; i++)
 680     {
 681         out[i] = in[i]->command_buffer;
 682     }
 683
 684     return out;
 685 }
 686
 687 static inline void free_VkCommandBuffer_array(VkCommandBuffer *in, uint32_t count)
 688 {
 689     if (!in) return;
 690
 691     free(in);
 692 }
 693
 694 #if defined(USE_STRUCT_CONVERSION)
 695 static inline VkIndirectCommandsStreamNV_host *convert_VkIndirectCommandsStreamNV_array_win_to_host(const VkIndirectCommandsStreamNV *in, uint32_t count)
 696 {
 697     VkIndirectCommandsStreamNV_host *out;
 698     unsigned int i;
 699
 700     if (!in) return NULL;
 701
 702     out = malloc(count * sizeof(*out));
 703     for (i = 0; i < count; i++)
 704     {
 705         out[i].buffer = in[i].buffer;
 706         out[i].offset = in[i].offset;
 707     }
 708
 709     return out;
 710 }
 711 #endif /* USE_STRUCT_CONVERSION */
 712
 713 #if defined(USE_STRUCT_CONVERSION)
 714 static inline void free_VkIndirectCommandsStreamNV_array(VkIndirectCommandsStreamNV_host *in, uint32_t count)
 715 {
 716     if (!in) return;
 717
 718     free(in);
 719 }
 720 #endif /* USE_STRUCT_CONVERSION */
 721
 722 #if defined(USE_STRUCT_CONVERSION)
 723 static inline void convert_VkGeneratedCommandsInfoNV_win_to_host(const VkGeneratedCommandsInfoNV *in, VkGeneratedCommandsInfoNV_host *out)
 724 {
 725     if (!in) return;
 726
 727     out->sType = in->sType;
 728     out->pNext = in->pNext;
 729     out->pipelineBindPoint = in->pipelineBindPoint;
 730     out->pipeline = in->pipeline;
 731     out->indirectCommandsLayout = in->indirectCommandsLayout;
 732     out->streamCount = in->streamCount;
 733     out->pStreams = convert_VkIndirectCommandsStreamNV_array_win_to_host(in->pStreams, in->streamCount);
 734     out->sequencesCount = in->sequencesCount;
 735     out->preprocessBuffer = in->preprocessBuffer;
 736     out->preprocessOffset = in->preprocessOffset;
 737     out->preprocessSize = in->preprocessSize;
 738     out->sequencesCountBuffer = in->sequencesCountBuffer;
 739     out->sequencesCountOffset = in->sequencesCountOffset;
 740     out->sequencesIndexBuffer = in->sequencesIndexBuffer;
 741     out->sequencesIndexOffset = in->sequencesIndexOffset;
 742 }
 743 #endif /* USE_STRUCT_CONVERSION */
 744
 745 #if defined(USE_STRUCT_CONVERSION)
 746 static inline void free_VkGeneratedCommandsInfoNV(VkGeneratedCommandsInfoNV_host *in)
 747 {
 748     free_VkIndirectCommandsStreamNV_array((VkIndirectCommandsStreamNV_host *)in->pStreams, in->streamCount);
 749 }
 750 #endif /* USE_STRUCT_CONVERSION */
 751
 752 #if defined(USE_STRUCT_CONVERSION)
 753 static inline VkBufferMemoryBarrier_host *convert_VkBufferMemoryBarrier_array_win_to_host(const VkBufferMemoryBarrier *in, uint32_t count)
 754 {
 755     VkBufferMemoryBarrier_host *out;
 756     unsigned int i;
 757
 758     if (!in) return NULL;
 759
 760     out = malloc(count * sizeof(*out));
 761     for (i = 0; i < count; i++)
 762     {
 763         out[i].sType = in[i].sType;
 764         out[i].pNext = in[i].pNext;
 765         out[i].srcAccessMask = in[i].srcAccessMask;
 766         out[i].dstAccessMask = in[i].dstAccessMask;
 767         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 768         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 769         out[i].buffer = in[i].buffer;
 770         out[i].offset = in[i].offset;
 771         out[i].size = in[i].size;
 772     }
 773
 774     return out;
 775 }
 776 #endif /* USE_STRUCT_CONVERSION */
 777
 778 #if defined(USE_STRUCT_CONVERSION)
 779 static inline void free_VkBufferMemoryBarrier_array(VkBufferMemoryBarrier_host *in, uint32_t count)
 780 {
 781     if (!in) return;
 782
 783     free(in);
 784 }
 785 #endif /* USE_STRUCT_CONVERSION */
 786
 787 #if defined(USE_STRUCT_CONVERSION)
 788 static inline VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier_array_win_to_host(const VkImageMemoryBarrier *in, uint32_t count)
 789 {
 790     VkImageMemoryBarrier_host *out;
 791     unsigned int i;
 792
 793     if (!in) return NULL;
 794
 795     out = malloc(count * sizeof(*out));
 796     for (i = 0; i < count; i++)
 797     {
 798         out[i].sType = in[i].sType;
 799         out[i].pNext = in[i].pNext;
 800         out[i].srcAccessMask = in[i].srcAccessMask;
 801         out[i].dstAccessMask = in[i].dstAccessMask;
 802         out[i].oldLayout = in[i].oldLayout;
 803         out[i].newLayout = in[i].newLayout;
 804         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 805         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 806         out[i].image = in[i].image;
 807         out[i].subresourceRange = in[i].subresourceRange;
 808     }
 809
 810     return out;
 811 }
 812 #endif /* USE_STRUCT_CONVERSION */
 813
 814 #if defined(USE_STRUCT_CONVERSION)
 815 static inline void free_VkImageMemoryBarrier_array(VkImageMemoryBarrier_host *in, uint32_t count)
 816 {
 817     if (!in) return;
 818
 819     free(in);
 820 }
 821 #endif /* USE_STRUCT_CONVERSION */
 822
 823 #if defined(USE_STRUCT_CONVERSION)
 824 static inline VkBufferMemoryBarrier2KHR_host *convert_VkBufferMemoryBarrier2KHR_array_win_to_host(const VkBufferMemoryBarrier2KHR *in, uint32_t count)
 825 {
 826     VkBufferMemoryBarrier2KHR_host *out;
 827     unsigned int i;
 828
 829     if (!in) return NULL;
 830
 831     out = malloc(count * sizeof(*out));
 832     for (i = 0; i < count; i++)
 833     {
 834         out[i].sType = in[i].sType;
 835         out[i].pNext = in[i].pNext;
 836         out[i].srcStageMask = in[i].srcStageMask;
 837         out[i].srcAccessMask = in[i].srcAccessMask;
 838         out[i].dstStageMask = in[i].dstStageMask;
 839         out[i].dstAccessMask = in[i].dstAccessMask;
 840         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 841         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 842         out[i].buffer = in[i].buffer;
 843         out[i].offset = in[i].offset;
 844         out[i].size = in[i].size;
 845     }
 846
 847     return out;
 848 }
 849 #endif /* USE_STRUCT_CONVERSION */
 850
 851 #if defined(USE_STRUCT_CONVERSION)
 852 static inline void free_VkBufferMemoryBarrier2KHR_array(VkBufferMemoryBarrier2KHR_host *in, uint32_t count)
 853 {
 854     if (!in) return;
 855
 856     free(in);
 857 }
 858 #endif /* USE_STRUCT_CONVERSION */
 859
 860 #if defined(USE_STRUCT_CONVERSION)
 861 static inline VkImageMemoryBarrier2KHR_host *convert_VkImageMemoryBarrier2KHR_array_win_to_host(const VkImageMemoryBarrier2KHR *in, uint32_t count)
 862 {
 863     VkImageMemoryBarrier2KHR_host *out;
 864     unsigned int i;
 865
 866     if (!in) return NULL;
 867
 868     out = malloc(count * sizeof(*out));
 869     for (i = 0; i < count; i++)
 870     {
 871         out[i].sType = in[i].sType;
 872         out[i].pNext = in[i].pNext;
 873         out[i].srcStageMask = in[i].srcStageMask;
 874         out[i].srcAccessMask = in[i].srcAccessMask;
 875         out[i].dstStageMask = in[i].dstStageMask;
 876         out[i].dstAccessMask = in[i].dstAccessMask;
 877         out[i].oldLayout = in[i].oldLayout;
 878         out[i].newLayout = in[i].newLayout;
 879         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 880         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 881         out[i].image = in[i].image;
 882         out[i].subresourceRange = in[i].subresourceRange;
 883     }
 884
 885     return out;
 886 }
 887 #endif /* USE_STRUCT_CONVERSION */
 888
 889 #if defined(USE_STRUCT_CONVERSION)
 890 static inline void free_VkImageMemoryBarrier2KHR_array(VkImageMemoryBarrier2KHR_host *in, uint32_t count)
 891 {
 892     if (!in) return;
 893
 894     free(in);
 895 }
 896 #endif /* USE_STRUCT_CONVERSION */
 897
 898 #if defined(USE_STRUCT_CONVERSION)
 899 static inline void convert_VkDependencyInfoKHR_win_to_host(const VkDependencyInfoKHR *in, VkDependencyInfoKHR_host *out)
 900 {
 901     if (!in) return;
 902
 903     out->sType = in->sType;
 904     out->pNext = in->pNext;
 905     out->dependencyFlags = in->dependencyFlags;
 906     out->memoryBarrierCount = in->memoryBarrierCount;
 907     out->pMemoryBarriers = in->pMemoryBarriers;
 908     out->bufferMemoryBarrierCount = in->bufferMemoryBarrierCount;
 909     out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2KHR_array_win_to_host(in->pBufferMemoryBarriers, in->bufferMemoryBarrierCount);
 910     out->imageMemoryBarrierCount = in->imageMemoryBarrierCount;
 911     out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2KHR_array_win_to_host(in->pImageMemoryBarriers, in->imageMemoryBarrierCount);
 912 }
 913 #endif /* USE_STRUCT_CONVERSION */
 914
 915 #if defined(USE_STRUCT_CONVERSION)
 916 static inline void free_VkDependencyInfoKHR(VkDependencyInfoKHR_host *in)
 917 {
 918     free_VkBufferMemoryBarrier2KHR_array((VkBufferMemoryBarrier2KHR_host *)in->pBufferMemoryBarriers, in->bufferMemoryBarrierCount);
 919     free_VkImageMemoryBarrier2KHR_array((VkImageMemoryBarrier2KHR_host *)in->pImageMemoryBarriers, in->imageMemoryBarrierCount);
 920 }
 921 #endif /* USE_STRUCT_CONVERSION */
 922
 923 #if defined(USE_STRUCT_CONVERSION)
 924 static inline VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array_win_to_host(const VkDescriptorImageInfo *in, uint32_t count)
 925 {
 926     VkDescriptorImageInfo_host *out;
 927     unsigned int i;
 928
 929     if (!in) return NULL;
 930
 931     out = malloc(count * sizeof(*out));
 932     for (i = 0; i < count; i++)
 933     {
 934         out[i].sampler = in[i].sampler;
 935         out[i].imageView = in[i].imageView;
 936         out[i].imageLayout = in[i].imageLayout;
 937     }
 938
 939     return out;
 940 }
 941 #endif /* USE_STRUCT_CONVERSION */
 942
 943 #if defined(USE_STRUCT_CONVERSION)
 944 static inline void free_VkDescriptorImageInfo_array(VkDescriptorImageInfo_host *in, uint32_t count)
 945 {
 946     if (!in) return;
 947
 948     free(in);
 949 }
 950 #endif /* USE_STRUCT_CONVERSION */
 951
 952 #if defined(USE_STRUCT_CONVERSION)
 953 static inline VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array_win_to_host(const VkDescriptorBufferInfo *in, uint32_t count)
 954 {
 955     VkDescriptorBufferInfo_host *out;
 956     unsigned int i;
 957
 958     if (!in) return NULL;
 959
 960     out = malloc(count * sizeof(*out));
 961     for (i = 0; i < count; i++)
 962     {
 963         out[i].buffer = in[i].buffer;
 964         out[i].offset = in[i].offset;
 965         out[i].range = in[i].range;
 966     }
 967
 968     return out;
 969 }
 970 #endif /* USE_STRUCT_CONVERSION */
 971
 972 #if defined(USE_STRUCT_CONVERSION)
 973 static inline void free_VkDescriptorBufferInfo_array(VkDescriptorBufferInfo_host *in, uint32_t count)
 974 {
 975     if (!in) return;
 976
 977     free(in);
 978 }
 979 #endif /* USE_STRUCT_CONVERSION */
 980
 981 #if defined(USE_STRUCT_CONVERSION)
 982 static inline VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array_win_to_host(const VkWriteDescriptorSet *in, uint32_t count)
 983 {
 984     VkWriteDescriptorSet_host *out;
 985     unsigned int i;
 986
 987     if (!in) return NULL;
 988
 989     out = malloc(count * sizeof(*out));
 990     for (i = 0; i < count; i++)
 991     {
 992         out[i].sType = in[i].sType;
 993         out[i].pNext = in[i].pNext;
 994         out[i].dstSet = in[i].dstSet;
 995         out[i].dstBinding = in[i].dstBinding;
 996         out[i].dstArrayElement = in[i].dstArrayElement;
 997         out[i].descriptorCount = in[i].descriptorCount;
 998         out[i].descriptorType = in[i].descriptorType;
 999         out[i].pImageInfo = convert_VkDescriptorImageInfo_array_win_to_host(in[i].pImageInfo, in[i].descriptorCount);
1000         out[i].pBufferInfo = convert_VkDescriptorBufferInfo_array_win_to_host(in[i].pBufferInfo, in[i].descriptorCount);
1001         out[i].pTexelBufferView = in[i].pTexelBufferView;
1002     }
1003
1004     return out;
1005 }
1006 #endif /* USE_STRUCT_CONVERSION */
1007
1008 #if defined(USE_STRUCT_CONVERSION)
1009 static inline void free_VkWriteDescriptorSet_array(VkWriteDescriptorSet_host *in, uint32_t count)
1010 {
1011     unsigned int i;
1012
1013     if (!in) return;
1014
1015     for (i = 0; i < count; i++)
1016     {
1017         free_VkDescriptorImageInfo_array((VkDescriptorImageInfo_host *)in[i].pImageInfo, in[i].descriptorCount);
1018         free_VkDescriptorBufferInfo_array((VkDescriptorBufferInfo_host *)in[i].pBufferInfo, in[i].descriptorCount);
1019     }
1020     free(in);
1021 }
1022 #endif /* USE_STRUCT_CONVERSION */
1023
1024 #if defined(USE_STRUCT_CONVERSION)
1025 static inline void convert_VkResolveImageInfo2KHR_win_to_host(const VkResolveImageInfo2KHR *in, VkResolveImageInfo2KHR_host *out)
1026 {
1027     if (!in) return;
1028
1029     out->sType = in->sType;
1030     out->pNext = in->pNext;
1031     out->srcImage = in->srcImage;
1032     out->srcImageLayout = in->srcImageLayout;
1033     out->dstImage = in->dstImage;
1034     out->dstImageLayout = in->dstImageLayout;
1035     out->regionCount = in->regionCount;
1036     out->pRegions = in->pRegions;
1037 }
1038 #endif /* USE_STRUCT_CONVERSION */
1039
1040 #if defined(USE_STRUCT_CONVERSION)
1041 static inline void convert_VkPerformanceMarkerInfoINTEL_win_to_host(const VkPerformanceMarkerInfoINTEL *in, VkPerformanceMarkerInfoINTEL_host *out)
1042 {
1043     if (!in) return;
1044
1045     out->sType = in->sType;
1046     out->pNext = in->pNext;
1047     out->marker = in->marker;
1048 }
1049 #endif /* USE_STRUCT_CONVERSION */
1050
1051 #if defined(USE_STRUCT_CONVERSION)
1052 static inline void convert_VkPerformanceOverrideInfoINTEL_win_to_host(const VkPerformanceOverrideInfoINTEL *in, VkPerformanceOverrideInfoINTEL_host *out)
1053 {
1054     if (!in) return;
1055
1056     out->sType = in->sType;
1057     out->pNext = in->pNext;
1058     out->type = in->type;
1059     out->enable = in->enable;
1060     out->parameter = in->parameter;
1061 }
1062 #endif /* USE_STRUCT_CONVERSION */
1063
1064 #if defined(USE_STRUCT_CONVERSION)
1065 static inline void convert_VkStridedDeviceAddressRegionKHR_win_to_host(const VkStridedDeviceAddressRegionKHR *in, VkStridedDeviceAddressRegionKHR_host *out)
1066 {
1067     if (!in) return;
1068
1069     out->deviceAddress = in->deviceAddress;
1070     out->stride = in->stride;
1071     out->size = in->size;
1072 }
1073 #endif /* USE_STRUCT_CONVERSION */
1074
1075 #if defined(USE_STRUCT_CONVERSION)
1076 static inline VkDependencyInfoKHR_host *convert_VkDependencyInfoKHR_array_win_to_host(const VkDependencyInfoKHR *in, uint32_t count)
1077 {
1078     VkDependencyInfoKHR_host *out;
1079     unsigned int i;
1080
1081     if (!in) return NULL;
1082
1083     out = malloc(count * sizeof(*out));
1084     for (i = 0; i < count; i++)
1085     {
1086         out[i].sType = in[i].sType;
1087         out[i].pNext = in[i].pNext;
1088         out[i].dependencyFlags = in[i].dependencyFlags;
1089         out[i].memoryBarrierCount = in[i].memoryBarrierCount;
1090         out[i].pMemoryBarriers = in[i].pMemoryBarriers;
1091         out[i].bufferMemoryBarrierCount = in[i].bufferMemoryBarrierCount;
1092         out[i].pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2KHR_array_win_to_host(in[i].pBufferMemoryBarriers, in[i].bufferMemoryBarrierCount);
1093         out[i].imageMemoryBarrierCount = in[i].imageMemoryBarrierCount;
1094         out[i].pImageMemoryBarriers = convert_VkImageMemoryBarrier2KHR_array_win_to_host(in[i].pImageMemoryBarriers, in[i].imageMemoryBarrierCount);
1095     }
1096
1097     return out;
1098 }
1099 #endif /* USE_STRUCT_CONVERSION */
1100
1101 #if defined(USE_STRUCT_CONVERSION)
1102 static inline void free_VkDependencyInfoKHR_array(VkDependencyInfoKHR_host *in, uint32_t count)
1103 {
1104     unsigned int i;
1105
1106     if (!in) return;
1107
1108     for (i = 0; i < count; i++)
1109     {
1110         free_VkBufferMemoryBarrier2KHR_array((VkBufferMemoryBarrier2KHR_host *)in[i].pBufferMemoryBarriers, in[i].bufferMemoryBarrierCount);
1111         free_VkImageMemoryBarrier2KHR_array((VkImageMemoryBarrier2KHR_host *)in[i].pImageMemoryBarriers, in[i].imageMemoryBarrierCount);
1112     }
1113     free(in);
1114 }
1115 #endif /* USE_STRUCT_CONVERSION */
1116
1117 #if defined(USE_STRUCT_CONVERSION)
1118 static inline void convert_VkAccelerationStructureCreateInfoKHR_win_to_host(const VkAccelerationStructureCreateInfoKHR *in, VkAccelerationStructureCreateInfoKHR_host *out)
1119 {
1120     if (!in) return;
1121
1122     out->sType = in->sType;
1123     out->pNext = in->pNext;
1124     out->createFlags = in->createFlags;
1125     out->buffer = in->buffer;
1126     out->offset = in->offset;
1127     out->size = in->size;
1128     out->type = in->type;
1129     out->deviceAddress = in->deviceAddress;
1130 }
1131 #endif /* USE_STRUCT_CONVERSION */
1132
1133 #if defined(USE_STRUCT_CONVERSION)
1134 static inline void convert_VkAccelerationStructureCreateInfoNV_win_to_host(const VkAccelerationStructureCreateInfoNV *in, VkAccelerationStructureCreateInfoNV_host *out)
1135 {
1136     if (!in) return;
1137
1138     out->sType = in->sType;
1139     out->pNext = in->pNext;
1140     out->compactedSize = in->compactedSize;
1141     convert_VkAccelerationStructureInfoNV_win_to_host(&in->info, &out->info);
1142 }
1143 #endif /* USE_STRUCT_CONVERSION */
1144
1145 #if defined(USE_STRUCT_CONVERSION)
1146 static inline void convert_VkBufferCreateInfo_win_to_host(const VkBufferCreateInfo *in, VkBufferCreateInfo_host *out)
1147 {
1148     if (!in) return;
1149
1150     out->sType = in->sType;
1151     out->pNext = in->pNext;
1152     out->flags = in->flags;
1153     out->size = in->size;
1154     out->usage = in->usage;
1155     out->sharingMode = in->sharingMode;
1156     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
1157     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
1158 }
1159 #endif /* USE_STRUCT_CONVERSION */
1160
1161 #if defined(USE_STRUCT_CONVERSION)
1162 static inline void convert_VkBufferViewCreateInfo_win_to_host(const VkBufferViewCreateInfo *in, VkBufferViewCreateInfo_host *out)
1163 {
1164     if (!in) return;
1165
1166     out->sType = in->sType;
1167     out->pNext = in->pNext;
1168     out->flags = in->flags;
1169     out->buffer = in->buffer;
1170     out->format = in->format;
1171     out->offset = in->offset;
1172     out->range = in->range;
1173 }
1174 #endif /* USE_STRUCT_CONVERSION */
1175
1176 #if defined(USE_STRUCT_CONVERSION)
1177 static inline void convert_VkPipelineShaderStageCreateInfo_win_to_host(const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo_host *out)
1178 {
1179     if (!in) return;
1180
1181     out->sType = in->sType;
1182     out->pNext = in->pNext;
1183     out->flags = in->flags;
1184     out->stage = in->stage;
1185     out->module = in->module;
1186     out->pName = in->pName;
1187     out->pSpecializationInfo = in->pSpecializationInfo;
1188 }
1189 #endif /* USE_STRUCT_CONVERSION */
1190
1191 #if defined(USE_STRUCT_CONVERSION)
1192 static inline VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo_array_win_to_host(const VkComputePipelineCreateInfo *in, uint32_t count)
1193 {
1194     VkComputePipelineCreateInfo_host *out;
1195     unsigned int i;
1196
1197     if (!in) return NULL;
1198
1199     out = malloc(count * sizeof(*out));
1200     for (i = 0; i < count; i++)
1201     {
1202         out[i].sType = in[i].sType;
1203         out[i].pNext = in[i].pNext;
1204         out[i].flags = in[i].flags;
1205         convert_VkPipelineShaderStageCreateInfo_win_to_host(&in[i].stage, &out[i].stage);
1206         out[i].layout = in[i].layout;
1207         out[i].basePipelineHandle = in[i].basePipelineHandle;
1208         out[i].basePipelineIndex = in[i].basePipelineIndex;
1209     }
1210
1211     return out;
1212 }
1213 #endif /* USE_STRUCT_CONVERSION */
1214
1215 #if defined(USE_STRUCT_CONVERSION)
1216 static inline void free_VkComputePipelineCreateInfo_array(VkComputePipelineCreateInfo_host *in, uint32_t count)
1217 {
1218     if (!in) return;
1219
1220     free(in);
1221 }
1222 #endif /* USE_STRUCT_CONVERSION */
1223
1224 #if defined(USE_STRUCT_CONVERSION)
1225 static inline void convert_VkCuFunctionCreateInfoNVX_win_to_host(const VkCuFunctionCreateInfoNVX *in, VkCuFunctionCreateInfoNVX_host *out)
1226 {
1227     if (!in) return;
1228
1229     out->sType = in->sType;
1230     out->pNext = in->pNext;
1231     out->module = in->module;
1232     out->pName = in->pName;
1233 }
1234 #endif /* USE_STRUCT_CONVERSION */
1235
1236 #if defined(USE_STRUCT_CONVERSION)
1237 static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(const VkDescriptorUpdateTemplateCreateInfo *in, VkDescriptorUpdateTemplateCreateInfo_host *out)
1238 {
1239     if (!in) return;
1240
1241     out->sType = in->sType;
1242     out->pNext = in->pNext;
1243     out->flags = in->flags;
1244     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
1245     out->pDescriptorUpdateEntries = in->pDescriptorUpdateEntries;
1246     out->templateType = in->templateType;
1247     out->descriptorSetLayout = in->descriptorSetLayout;
1248     out->pipelineBindPoint = in->pipelineBindPoint;
1249     out->pipelineLayout = in->pipelineLayout;
1250     out->set = in->set;
1251 }
1252 #endif /* USE_STRUCT_CONVERSION */
1253
1254 #if defined(USE_STRUCT_CONVERSION)
1255 static inline void convert_VkFramebufferCreateInfo_win_to_host(const VkFramebufferCreateInfo *in, VkFramebufferCreateInfo_host *out)
1256 {
1257     if (!in) return;
1258
1259     out->sType = in->sType;
1260     out->pNext = in->pNext;
1261     out->flags = in->flags;
1262     out->renderPass = in->renderPass;
1263     out->attachmentCount = in->attachmentCount;
1264     out->pAttachments = in->pAttachments;
1265     out->width = in->width;
1266     out->height = in->height;
1267     out->layers = in->layers;
1268 }
1269 #endif /* USE_STRUCT_CONVERSION */
1270
1271 #if defined(USE_STRUCT_CONVERSION)
1272 static inline VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo_array_win_to_host(const VkPipelineShaderStageCreateInfo *in, uint32_t count)
1273 {
1274     VkPipelineShaderStageCreateInfo_host *out;
1275     unsigned int i;
1276
1277     if (!in) return NULL;
1278
1279     out = malloc(count * sizeof(*out));
1280     for (i = 0; i < count; i++)
1281     {
1282         out[i].sType = in[i].sType;
1283         out[i].pNext = in[i].pNext;
1284         out[i].flags = in[i].flags;
1285         out[i].stage = in[i].stage;
1286         out[i].module = in[i].module;
1287         out[i].pName = in[i].pName;
1288         out[i].pSpecializationInfo = in[i].pSpecializationInfo;
1289     }
1290
1291     return out;
1292 }
1293 #endif /* USE_STRUCT_CONVERSION */
1294
1295 #if defined(USE_STRUCT_CONVERSION)
1296 static inline void free_VkPipelineShaderStageCreateInfo_array(VkPipelineShaderStageCreateInfo_host *in, uint32_t count)
1297 {
1298     if (!in) return;
1299
1300     free(in);
1301 }
1302 #endif /* USE_STRUCT_CONVERSION */
1303
1304 #if defined(USE_STRUCT_CONVERSION)
1305 static inline VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo_array_win_to_host(const VkGraphicsPipelineCreateInfo *in, uint32_t count)
1306 {
1307     VkGraphicsPipelineCreateInfo_host *out;
1308     unsigned int i;
1309
1310     if (!in) return NULL;
1311
1312     out = malloc(count * sizeof(*out));
1313     for (i = 0; i < count; i++)
1314     {
1315         out[i].sType = in[i].sType;
1316         out[i].pNext = in[i].pNext;
1317         out[i].flags = in[i].flags;
1318         out[i].stageCount = in[i].stageCount;
1319         out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win_to_host(in[i].pStages, in[i].stageCount);
1320         out[i].pVertexInputState = in[i].pVertexInputState;
1321         out[i].pInputAssemblyState = in[i].pInputAssemblyState;
1322         out[i].pTessellationState = in[i].pTessellationState;
1323         out[i].pViewportState = in[i].pViewportState;
1324         out[i].pRasterizationState = in[i].pRasterizationState;
1325         out[i].pMultisampleState = in[i].pMultisampleState;
1326         out[i].pDepthStencilState = in[i].pDepthStencilState;
1327         out[i].pColorBlendState = in[i].pColorBlendState;
1328         out[i].pDynamicState = in[i].pDynamicState;
1329         out[i].layout = in[i].layout;
1330         out[i].renderPass = in[i].renderPass;
1331         out[i].subpass = in[i].subpass;
1332         out[i].basePipelineHandle = in[i].basePipelineHandle;
1333         out[i].basePipelineIndex = in[i].basePipelineIndex;
1334     }
1335
1336     return out;
1337 }
1338 #endif /* USE_STRUCT_CONVERSION */
1339
1340 #if defined(USE_STRUCT_CONVERSION)
1341 static inline void free_VkGraphicsPipelineCreateInfo_array(VkGraphicsPipelineCreateInfo_host *in, uint32_t count)
1342 {
1343     unsigned int i;
1344
1345     if (!in) return;
1346
1347     for (i = 0; i < count; i++)
1348     {
1349         free_VkPipelineShaderStageCreateInfo_array((VkPipelineShaderStageCreateInfo_host *)in[i].pStages, in[i].stageCount);
1350     }
1351     free(in);
1352 }
1353 #endif /* USE_STRUCT_CONVERSION */
1354
1355 #if defined(USE_STRUCT_CONVERSION)
1356 static inline void convert_VkImageViewCreateInfo_win_to_host(const VkImageViewCreateInfo *in, VkImageViewCreateInfo_host *out)
1357 {
1358     if (!in) return;
1359
1360     out->sType = in->sType;
1361     out->pNext = in->pNext;
1362     out->flags = in->flags;
1363     out->image = in->image;
1364     out->viewType = in->viewType;
1365     out->format = in->format;
1366     out->components = in->components;
1367     out->subresourceRange = in->subresourceRange;
1368 }
1369 #endif /* USE_STRUCT_CONVERSION */
1370
1371 #if defined(USE_STRUCT_CONVERSION)
1372 static inline VkIndirectCommandsLayoutTokenNV_host *convert_VkIndirectCommandsLayoutTokenNV_array_win_to_host(const VkIndirectCommandsLayoutTokenNV *in, uint32_t count)
1373 {
1374     VkIndirectCommandsLayoutTokenNV_host *out;
1375     unsigned int i;
1376
1377     if (!in) return NULL;
1378
1379     out = malloc(count * sizeof(*out));
1380     for (i = 0; i < count; i++)
1381     {
1382         out[i].sType = in[i].sType;
1383         out[i].pNext = in[i].pNext;
1384         out[i].tokenType = in[i].tokenType;
1385         out[i].stream = in[i].stream;
1386         out[i].offset = in[i].offset;
1387         out[i].vertexBindingUnit = in[i].vertexBindingUnit;
1388         out[i].vertexDynamicStride = in[i].vertexDynamicStride;
1389         out[i].pushconstantPipelineLayout = in[i].pushconstantPipelineLayout;
1390         out[i].pushconstantShaderStageFlags = in[i].pushconstantShaderStageFlags;
1391         out[i].pushconstantOffset = in[i].pushconstantOffset;
1392         out[i].pushconstantSize = in[i].pushconstantSize;
1393         out[i].indirectStateFlags = in[i].indirectStateFlags;
1394         out[i].indexTypeCount = in[i].indexTypeCount;
1395         out[i].pIndexTypes = in[i].pIndexTypes;
1396         out[i].pIndexTypeValues = in[i].pIndexTypeValues;
1397     }
1398
1399     return out;
1400 }
1401 #endif /* USE_STRUCT_CONVERSION */
1402
1403 #if defined(USE_STRUCT_CONVERSION)
1404 static inline void free_VkIndirectCommandsLayoutTokenNV_array(VkIndirectCommandsLayoutTokenNV_host *in, uint32_t count)
1405 {
1406     if (!in) return;
1407
1408     free(in);
1409 }
1410 #endif /* USE_STRUCT_CONVERSION */
1411
1412 #if defined(USE_STRUCT_CONVERSION)
1413 static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win_to_host(const VkIndirectCommandsLayoutCreateInfoNV *in, VkIndirectCommandsLayoutCreateInfoNV_host *out)
1414 {
1415     if (!in) return;
1416
1417     out->sType = in->sType;
1418     out->pNext = in->pNext;
1419     out->flags = in->flags;
1420     out->pipelineBindPoint = in->pipelineBindPoint;
1421     out->tokenCount = in->tokenCount;
1422     out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win_to_host(in->pTokens, in->tokenCount);
1423     out->streamCount = in->streamCount;
1424     out->pStreamStrides = in->pStreamStrides;
1425 }
1426 #endif /* USE_STRUCT_CONVERSION */
1427
1428 #if defined(USE_STRUCT_CONVERSION)
1429 static inline void free_VkIndirectCommandsLayoutCreateInfoNV(VkIndirectCommandsLayoutCreateInfoNV_host *in)
1430 {
1431     free_VkIndirectCommandsLayoutTokenNV_array((VkIndirectCommandsLayoutTokenNV_host *)in->pTokens, in->tokenCount);
1432 }
1433 #endif /* USE_STRUCT_CONVERSION */
1434
1435 #if defined(USE_STRUCT_CONVERSION)
1436 static inline VkRayTracingPipelineCreateInfoKHR_host *convert_VkRayTracingPipelineCreateInfoKHR_array_win_to_host(const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
1437 {
1438     VkRayTracingPipelineCreateInfoKHR_host *out;
1439     unsigned int i;
1440
1441     if (!in) return NULL;
1442
1443     out = malloc(count * sizeof(*out));
1444     for (i = 0; i < count; i++)
1445     {
1446         out[i].sType = in[i].sType;
1447         out[i].pNext = in[i].pNext;
1448         out[i].flags = in[i].flags;
1449         out[i].stageCount = in[i].stageCount;
1450         out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win_to_host(in[i].pStages, in[i].stageCount);
1451         out[i].groupCount = in[i].groupCount;
1452         out[i].pGroups = in[i].pGroups;
1453         out[i].maxPipelineRayRecursionDepth = in[i].maxPipelineRayRecursionDepth;
1454         out[i].pLibraryInfo = in[i].pLibraryInfo;
1455         out[i].pLibraryInterface = in[i].pLibraryInterface;
1456         out[i].pDynamicState = in[i].pDynamicState;
1457         out[i].layout = in[i].layout;
1458         out[i].basePipelineHandle = in[i].basePipelineHandle;
1459         out[i].basePipelineIndex = in[i].basePipelineIndex;
1460     }
1461
1462     return out;
1463 }
1464 #endif /* USE_STRUCT_CONVERSION */
1465
1466 #if defined(USE_STRUCT_CONVERSION)
1467 static inline void free_VkRayTracingPipelineCreateInfoKHR_array(VkRayTracingPipelineCreateInfoKHR_host *in, uint32_t count)
1468 {
1469     unsigned int i;
1470
1471     if (!in) return;
1472
1473     for (i = 0; i < count; i++)
1474     {
1475         free_VkPipelineShaderStageCreateInfo_array((VkPipelineShaderStageCreateInfo_host *)in[i].pStages, in[i].stageCount);
1476     }
1477     free(in);
1478 }
1479 #endif /* USE_STRUCT_CONVERSION */
1480
1481 #if defined(USE_STRUCT_CONVERSION)
1482 static inline VkRayTracingPipelineCreateInfoNV_host *convert_VkRayTracingPipelineCreateInfoNV_array_win_to_host(const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
1483 {
1484     VkRayTracingPipelineCreateInfoNV_host *out;
1485     unsigned int i;
1486
1487     if (!in) return NULL;
1488
1489     out = malloc(count * sizeof(*out));
1490     for (i = 0; i < count; i++)
1491     {
1492         out[i].sType = in[i].sType;
1493         out[i].pNext = in[i].pNext;
1494         out[i].flags = in[i].flags;
1495         out[i].stageCount = in[i].stageCount;
1496         out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win_to_host(in[i].pStages, in[i].stageCount);
1497         out[i].groupCount = in[i].groupCount;
1498         out[i].pGroups = in[i].pGroups;
1499         out[i].maxRecursionDepth = in[i].maxRecursionDepth;
1500         out[i].layout = in[i].layout;
1501         out[i].basePipelineHandle = in[i].basePipelineHandle;
1502         out[i].basePipelineIndex = in[i].basePipelineIndex;
1503     }
1504
1505     return out;
1506 }
1507 #endif /* USE_STRUCT_CONVERSION */
1508
1509 #if defined(USE_STRUCT_CONVERSION)
1510 static inline void free_VkRayTracingPipelineCreateInfoNV_array(VkRayTracingPipelineCreateInfoNV_host *in, uint32_t count)
1511 {
1512     unsigned int i;
1513
1514     if (!in) return;
1515
1516     for (i = 0; i < count; i++)
1517     {
1518         free_VkPipelineShaderStageCreateInfo_array((VkPipelineShaderStageCreateInfo_host *)in[i].pStages, in[i].stageCount);
1519     }
1520     free(in);
1521 }
1522 #endif /* USE_STRUCT_CONVERSION */
1523
1524 #if defined(USE_STRUCT_CONVERSION)
1525 static inline void convert_VkSwapchainCreateInfoKHR_win_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR_host *out)
1526 #else
1527 static inline void convert_VkSwapchainCreateInfoKHR_win_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR *out)
1528 #endif /* USE_STRUCT_CONVERSION */
1529 {
1530     if (!in) return;
1531
1532     out->sType = in->sType;
1533     out->pNext = in->pNext;
1534     out->flags = in->flags;
1535     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
1536     out->minImageCount = in->minImageCount;
1537     out->imageFormat = in->imageFormat;
1538     out->imageColorSpace = in->imageColorSpace;
1539     out->imageExtent = in->imageExtent;
1540     out->imageArrayLayers = in->imageArrayLayers;
1541     out->imageUsage = in->imageUsage;
1542     out->imageSharingMode = in->imageSharingMode;
1543     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
1544     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
1545     out->preTransform = in->preTransform;
1546     out->compositeAlpha = in->compositeAlpha;
1547     out->presentMode = in->presentMode;
1548     out->clipped = in->clipped;
1549     out->oldSwapchain = in->oldSwapchain;
1550 }
1551
1552 #if defined(USE_STRUCT_CONVERSION)
1553 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT_host *out)
1554 #else
1555 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out)
1556 #endif /* USE_STRUCT_CONVERSION */
1557 {
1558     if (!in) return;
1559
1560     out->sType = in->sType;
1561     out->pNext = in->pNext;
1562     out->objectType = in->objectType;
1563     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
1564     out->pObjectName = in->pObjectName;
1565 }
1566
1567 #if defined(USE_STRUCT_CONVERSION)
1568 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT_host *out)
1569 #else
1570 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out)
1571 #endif /* USE_STRUCT_CONVERSION */
1572 {
1573     if (!in) return;
1574
1575     out->sType = in->sType;
1576     out->pNext = in->pNext;
1577     out->objectType = in->objectType;
1578     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
1579     out->tagName = in->tagName;
1580     out->tagSize = in->tagSize;
1581     out->pTag = in->pTag;
1582 }
1583
1584 #if defined(USE_STRUCT_CONVERSION)
1585 static inline VkMappedMemoryRange_host *convert_VkMappedMemoryRange_array_win_to_host(const VkMappedMemoryRange *in, uint32_t count)
1586 {
1587     VkMappedMemoryRange_host *out;
1588     unsigned int i;
1589
1590     if (!in) return NULL;
1591
1592     out = malloc(count * sizeof(*out));
1593     for (i = 0; i < count; i++)
1594     {
1595         out[i].sType = in[i].sType;
1596         out[i].pNext = in[i].pNext;
1597         out[i].memory = in[i].memory;
1598         out[i].offset = in[i].offset;
1599         out[i].size = in[i].size;
1600     }
1601
1602     return out;
1603 }
1604 #endif /* USE_STRUCT_CONVERSION */
1605
1606 #if defined(USE_STRUCT_CONVERSION)
1607 static inline void free_VkMappedMemoryRange_array(VkMappedMemoryRange_host *in, uint32_t count)
1608 {
1609     if (!in) return;
1610
1611     free(in);
1612 }
1613 #endif /* USE_STRUCT_CONVERSION */
1614
1615 #if defined(USE_STRUCT_CONVERSION)
1616 static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win_to_host(const VkAccelerationStructureBuildGeometryInfoKHR *in, VkAccelerationStructureBuildGeometryInfoKHR_host *out)
1617 {
1618     if (!in) return;
1619
1620     out->sType = in->sType;
1621     out->pNext = in->pNext;
1622     out->type = in->type;
1623     out->flags = in->flags;
1624     out->mode = in->mode;
1625     out->srcAccelerationStructure = in->srcAccelerationStructure;
1626     out->dstAccelerationStructure = in->dstAccelerationStructure;
1627     out->geometryCount = in->geometryCount;
1628     out->pGeometries = in->pGeometries;
1629     out->ppGeometries = in->ppGeometries;
1630     out->scratchData = in->scratchData;
1631 }
1632 #endif /* USE_STRUCT_CONVERSION */
1633
1634 #if defined(USE_STRUCT_CONVERSION)
1635 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win_to_host(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR_host *out)
1636 {
1637     if (!in) return;
1638
1639     out->sType = in->sType;
1640     out->pNext = in->pNext;
1641     out->accelerationStructureSize = in->accelerationStructureSize;
1642     out->updateScratchSize = in->updateScratchSize;
1643     out->buildScratchSize = in->buildScratchSize;
1644 }
1645 #endif /* USE_STRUCT_CONVERSION */
1646
1647 #if defined(USE_STRUCT_CONVERSION)
1648 static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win_to_host(const VkAccelerationStructureDeviceAddressInfoKHR *in, VkAccelerationStructureDeviceAddressInfoKHR_host *out)
1649 {
1650     if (!in) return;
1651
1652     out->sType = in->sType;
1653     out->pNext = in->pNext;
1654     out->accelerationStructure = in->accelerationStructure;
1655 }
1656 #endif /* USE_STRUCT_CONVERSION */
1657
1658 #if defined(USE_STRUCT_CONVERSION)
1659 static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV *in, VkAccelerationStructureMemoryRequirementsInfoNV_host *out)
1660 {
1661     if (!in) return;
1662
1663     out->sType = in->sType;
1664     out->pNext = in->pNext;
1665     out->type = in->type;
1666     out->accelerationStructure = in->accelerationStructure;
1667 }
1668 #endif /* USE_STRUCT_CONVERSION */
1669
1670 #if defined(USE_STRUCT_CONVERSION)
1671 static inline void convert_VkMemoryRequirements_host_to_win(const VkMemoryRequirements_host *in, VkMemoryRequirements *out)
1672 {
1673     if (!in) return;
1674
1675     out->size = in->size;
1676     out->alignment = in->alignment;
1677     out->memoryTypeBits = in->memoryTypeBits;
1678 }
1679 #endif /* USE_STRUCT_CONVERSION */
1680
1681 #if defined(USE_STRUCT_CONVERSION)
1682 static inline void convert_VkMemoryRequirements2KHR_win_to_host(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR_host *out)
1683 {
1684     if (!in) return;
1685
1686     out->pNext = in->pNext;
1687     out->sType = in->sType;
1688 }
1689 #endif /* USE_STRUCT_CONVERSION */
1690
1691 #if defined(USE_STRUCT_CONVERSION)
1692 static inline void convert_VkMemoryRequirements2KHR_host_to_win(const VkMemoryRequirements2KHR_host *in, VkMemoryRequirements2KHR *out)
1693 {
1694     if (!in) return;
1695
1696     out->sType = in->sType;
1697     out->pNext = in->pNext;
1698     convert_VkMemoryRequirements_host_to_win(&in->memoryRequirements, &out->memoryRequirements);
1699 }
1700 #endif /* USE_STRUCT_CONVERSION */
1701
1702 #if defined(USE_STRUCT_CONVERSION)
1703 static inline void convert_VkBufferDeviceAddressInfo_win_to_host(const VkBufferDeviceAddressInfo *in, VkBufferDeviceAddressInfo_host *out)
1704 {
1705     if (!in) return;
1706
1707     out->sType = in->sType;
1708     out->pNext = in->pNext;
1709     out->buffer = in->buffer;
1710 }
1711 #endif /* USE_STRUCT_CONVERSION */
1712
1713 #if defined(USE_STRUCT_CONVERSION)
1714 static inline void convert_VkBufferMemoryRequirementsInfo2_win_to_host(const VkBufferMemoryRequirementsInfo2 *in, VkBufferMemoryRequirementsInfo2_host *out)
1715 {
1716     if (!in) return;
1717
1718     out->sType = in->sType;
1719     out->pNext = in->pNext;
1720     out->buffer = in->buffer;
1721 }
1722 #endif /* USE_STRUCT_CONVERSION */
1723
1724 #if defined(USE_STRUCT_CONVERSION)
1725 static inline void convert_VkMemoryRequirements2_win_to_host(const VkMemoryRequirements2 *in, VkMemoryRequirements2_host *out)
1726 {
1727     if (!in) return;
1728
1729     out->pNext = in->pNext;
1730     out->sType = in->sType;
1731 }
1732 #endif /* USE_STRUCT_CONVERSION */
1733
1734 #if defined(USE_STRUCT_CONVERSION)
1735 static inline void convert_VkMemoryRequirements2_host_to_win(const VkMemoryRequirements2_host *in, VkMemoryRequirements2 *out)
1736 {
1737     if (!in) return;
1738
1739     out->sType = in->sType;
1740     out->pNext = in->pNext;
1741     convert_VkMemoryRequirements_host_to_win(&in->memoryRequirements, &out->memoryRequirements);
1742 }
1743 #endif /* USE_STRUCT_CONVERSION */
1744
1745 #if defined(USE_STRUCT_CONVERSION)
1746 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo_host *out)
1747 {
1748     if (!in) return;
1749
1750     out->sType = in->sType;
1751     out->pNext = in->pNext;
1752     out->memory = in->memory;
1753 }
1754 #endif /* USE_STRUCT_CONVERSION */
1755
1756 #if defined(USE_STRUCT_CONVERSION)
1757 static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV *in, VkGeneratedCommandsMemoryRequirementsInfoNV_host *out)
1758 {
1759     if (!in) return;
1760
1761     out->sType = in->sType;
1762     out->pNext = in->pNext;
1763     out->pipelineBindPoint = in->pipelineBindPoint;
1764     out->pipeline = in->pipeline;
1765     out->indirectCommandsLayout = in->indirectCommandsLayout;
1766     out->maxSequencesCount = in->maxSequencesCount;
1767 }
1768 #endif /* USE_STRUCT_CONVERSION */
1769
1770 #if defined(USE_STRUCT_CONVERSION)
1771 static inline void convert_VkImageMemoryRequirementsInfo2_win_to_host(const VkImageMemoryRequirementsInfo2 *in, VkImageMemoryRequirementsInfo2_host *out)
1772 {
1773     if (!in) return;
1774
1775     out->sType = in->sType;
1776     out->pNext = in->pNext;
1777     out->image = in->image;
1778 }
1779 #endif /* USE_STRUCT_CONVERSION */
1780
1781 #if defined(USE_STRUCT_CONVERSION)
1782 static inline void convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(const VkImageSparseMemoryRequirementsInfo2 *in, VkImageSparseMemoryRequirementsInfo2_host *out)
1783 {
1784     if (!in) return;
1785
1786     out->sType = in->sType;
1787     out->pNext = in->pNext;
1788     out->image = in->image;
1789 }
1790 #endif /* USE_STRUCT_CONVERSION */
1791
1792 #if defined(USE_STRUCT_CONVERSION)
1793 static inline void convert_VkSubresourceLayout_host_to_win(const VkSubresourceLayout_host *in, VkSubresourceLayout *out)
1794 {
1795     if (!in) return;
1796
1797     out->offset = in->offset;
1798     out->size = in->size;
1799     out->rowPitch = in->rowPitch;
1800     out->arrayPitch = in->arrayPitch;
1801     out->depthPitch = in->depthPitch;
1802 }
1803 #endif /* USE_STRUCT_CONVERSION */
1804
1805 #if defined(USE_STRUCT_CONVERSION)
1806 static inline void convert_VkImageViewAddressPropertiesNVX_win_to_host(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX_host *out)
1807 {
1808     if (!in) return;
1809
1810     out->pNext = in->pNext;
1811     out->sType = in->sType;
1812 }
1813 #endif /* USE_STRUCT_CONVERSION */
1814
1815 #if defined(USE_STRUCT_CONVERSION)
1816 static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win(const VkImageViewAddressPropertiesNVX_host *in, VkImageViewAddressPropertiesNVX *out)
1817 {
1818     if (!in) return;
1819
1820     out->sType = in->sType;
1821     out->pNext = in->pNext;
1822     out->deviceAddress = in->deviceAddress;
1823     out->size = in->size;
1824 }
1825 #endif /* USE_STRUCT_CONVERSION */
1826
1827 #if defined(USE_STRUCT_CONVERSION)
1828 static inline void convert_VkImageViewHandleInfoNVX_win_to_host(const VkImageViewHandleInfoNVX *in, VkImageViewHandleInfoNVX_host *out)
1829 {
1830     if (!in) return;
1831
1832     out->sType = in->sType;
1833     out->pNext = in->pNext;
1834     out->imageView = in->imageView;
1835     out->descriptorType = in->descriptorType;
1836     out->sampler = in->sampler;
1837 }
1838 #endif /* USE_STRUCT_CONVERSION */
1839
1840 #if defined(USE_STRUCT_CONVERSION)
1841 static inline void convert_VkMemoryGetWin32HandleInfoKHR_win_to_host(const VkMemoryGetWin32HandleInfoKHR *in, VkMemoryGetWin32HandleInfoKHR_host *out)
1842 {
1843     if (!in) return;
1844
1845     out->sType = in->sType;
1846     out->pNext = in->pNext;
1847     out->memory = in->memory;
1848     out->handleType = in->handleType;
1849 }
1850 #endif /* USE_STRUCT_CONVERSION */
1851
1852 #if defined(USE_STRUCT_CONVERSION)
1853 static inline void convert_VkImageFormatProperties_host_to_win(const VkImageFormatProperties_host *in, VkImageFormatProperties *out)
1854 {
1855     if (!in) return;
1856
1857     out->maxExtent = in->maxExtent;
1858     out->maxMipLevels = in->maxMipLevels;
1859     out->maxArrayLayers = in->maxArrayLayers;
1860     out->sampleCounts = in->sampleCounts;
1861     out->maxResourceSize = in->maxResourceSize;
1862 }
1863 #endif /* USE_STRUCT_CONVERSION */
1864
1865 #if defined(USE_STRUCT_CONVERSION)
1866 static inline void convert_VkImageFormatProperties2_win_to_host(const VkImageFormatProperties2 *in, VkImageFormatProperties2_host *out)
1867 {
1868     if (!in) return;
1869
1870     out->pNext = in->pNext;
1871     out->sType = in->sType;
1872 }
1873 #endif /* USE_STRUCT_CONVERSION */
1874
1875 #if defined(USE_STRUCT_CONVERSION)
1876 static inline void convert_VkImageFormatProperties2_host_to_win(const VkImageFormatProperties2_host *in, VkImageFormatProperties2 *out)
1877 {
1878     if (!in) return;
1879
1880     out->sType = in->sType;
1881     out->pNext = in->pNext;
1882     convert_VkImageFormatProperties_host_to_win(&in->imageFormatProperties, &out->imageFormatProperties);
1883 }
1884 #endif /* USE_STRUCT_CONVERSION */
1885
1886 #if defined(USE_STRUCT_CONVERSION)
1887 static inline void convert_VkMemoryHeap_static_array_host_to_win(const VkMemoryHeap_host *in, VkMemoryHeap *out, uint32_t count)
1888 {
1889     unsigned int i;
1890
1891     if (!in) return;
1892
1893     for (i = 0; i < count; i++)
1894     {
1895         out[i].size = in[i].size;
1896         out[i].flags = in[i].flags;
1897     }
1898 }
1899 #endif /* USE_STRUCT_CONVERSION) */
1900
1901 #if defined(USE_STRUCT_CONVERSION)
1902 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win(const VkPhysicalDeviceMemoryProperties_host *in, VkPhysicalDeviceMemoryProperties *out)
1903 {
1904     if (!in) return;
1905
1906     out->memoryTypeCount = in->memoryTypeCount;
1907     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
1908     out->memoryHeapCount = in->memoryHeapCount;
1909     convert_VkMemoryHeap_static_array_host_to_win(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
1910 }
1911 #endif /* USE_STRUCT_CONVERSION */
1912
1913 #if defined(USE_STRUCT_CONVERSION)
1914 static inline void convert_VkPhysicalDeviceMemoryProperties2_win_to_host(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties2_host *out)
1915 {
1916     if (!in) return;
1917
1918     out->pNext = in->pNext;
1919     out->sType = in->sType;
1920 }
1921 #endif /* USE_STRUCT_CONVERSION */
1922
1923 #if defined(USE_STRUCT_CONVERSION)
1924 static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win(const VkPhysicalDeviceMemoryProperties2_host *in, VkPhysicalDeviceMemoryProperties2 *out)
1925 {
1926     if (!in) return;
1927
1928     out->sType = in->sType;
1929     out->pNext = in->pNext;
1930     convert_VkPhysicalDeviceMemoryProperties_host_to_win(&in->memoryProperties, &out->memoryProperties);
1931 }
1932 #endif /* USE_STRUCT_CONVERSION */
1933
1934 #if defined(USE_STRUCT_CONVERSION)
1935 static inline void convert_VkPhysicalDeviceLimits_host_to_win(const VkPhysicalDeviceLimits_host *in, VkPhysicalDeviceLimits *out)
1936 {
1937     if (!in) return;
1938
1939     out->maxImageDimension1D = in->maxImageDimension1D;
1940     out->maxImageDimension2D = in->maxImageDimension2D;
1941     out->maxImageDimension3D = in->maxImageDimension3D;
1942     out->maxImageDimensionCube = in->maxImageDimensionCube;
1943     out->maxImageArrayLayers = in->maxImageArrayLayers;
1944     out->maxTexelBufferElements = in->maxTexelBufferElements;
1945     out->maxUniformBufferRange = in->maxUniformBufferRange;
1946     out->maxStorageBufferRange = in->maxStorageBufferRange;
1947     out->maxPushConstantsSize = in->maxPushConstantsSize;
1948     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
1949     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
1950     out->bufferImageGranularity = in->bufferImageGranularity;
1951     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
1952     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
1953     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
1954     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
1955     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
1956     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
1957     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
1958     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
1959     out->maxPerStageResources = in->maxPerStageResources;
1960     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
1961     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
1962     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
1963     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
1964     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
1965     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
1966     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
1967     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
1968     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
1969     out->maxVertexInputBindings = in->maxVertexInputBindings;
1970     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
1971     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
1972     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
1973     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
1974     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
1975     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
1976     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
1977     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
1978     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
1979     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
1980     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
1981     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
1982     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
1983     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
1984     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
1985     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
1986     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
1987     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
1988     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
1989     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
1990     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
1991     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
1992     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
1993     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
1994     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
1995     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
1996     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
1997     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
1998     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
1999     out->maxSamplerLodBias = in->maxSamplerLodBias;
2000     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
2001     out->maxViewports = in->maxViewports;
2002     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
2003     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
2004     out->viewportSubPixelBits = in->viewportSubPixelBits;
2005     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
2006     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
2007     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
2008     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
2009     out->minTexelOffset = in->minTexelOffset;
2010     out->maxTexelOffset = in->maxTexelOffset;
2011     out->minTexelGatherOffset = in->minTexelGatherOffset;
2012     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
2013     out->minInterpolationOffset = in->minInterpolationOffset;
2014     out->maxInterpolationOffset = in->maxInterpolationOffset;
2015     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
2016     out->maxFramebufferWidth = in->maxFramebufferWidth;
2017     out->maxFramebufferHeight = in->maxFramebufferHeight;
2018     out->maxFramebufferLayers = in->maxFramebufferLayers;
2019     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
2020     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
2021     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
2022     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
2023     out->maxColorAttachments = in->maxColorAttachments;
2024     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
2025     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
2026     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
2027     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
2028     out->storageImageSampleCounts = in->storageImageSampleCounts;
2029     out->maxSampleMaskWords = in->maxSampleMaskWords;
2030     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
2031     out->timestampPeriod = in->timestampPeriod;
2032     out->maxClipDistances = in->maxClipDistances;
2033     out->maxCullDistances = in->maxCullDistances;
2034     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
2035     out->discreteQueuePriorities = in->discreteQueuePriorities;
2036     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
2037     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
2038     out->pointSizeGranularity = in->pointSizeGranularity;
2039     out->lineWidthGranularity = in->lineWidthGranularity;
2040     out->strictLines = in->strictLines;
2041     out->standardSampleLocations = in->standardSampleLocations;
2042     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
2043     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
2044     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
2045 }
2046 #endif /* USE_STRUCT_CONVERSION */
2047
2048 #if defined(USE_STRUCT_CONVERSION)
2049 static inline void convert_VkPhysicalDeviceProperties_host_to_win(const VkPhysicalDeviceProperties_host *in, VkPhysicalDeviceProperties *out)
2050 {
2051     if (!in) return;
2052
2053     out->apiVersion = in->apiVersion;
2054     out->driverVersion = in->driverVersion;
2055     out->vendorID = in->vendorID;
2056     out->deviceID = in->deviceID;
2057     out->deviceType = in->deviceType;
2058     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
2059     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
2060     convert_VkPhysicalDeviceLimits_host_to_win(&in->limits, &out->limits);
2061     out->sparseProperties = in->sparseProperties;
2062 }
2063 #endif /* USE_STRUCT_CONVERSION */
2064
2065 #if defined(USE_STRUCT_CONVERSION)
2066 static inline void convert_VkPhysicalDeviceProperties2_win_to_host(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties2_host *out)
2067 {
2068     if (!in) return;
2069
2070     out->pNext = in->pNext;
2071     out->sType = in->sType;
2072 }
2073 #endif /* USE_STRUCT_CONVERSION */
2074
2075 #if defined(USE_STRUCT_CONVERSION)
2076 static inline void convert_VkPhysicalDeviceProperties2_host_to_win(const VkPhysicalDeviceProperties2_host *in, VkPhysicalDeviceProperties2 *out)
2077 {
2078     if (!in) return;
2079
2080     out->sType = in->sType;
2081     out->pNext = in->pNext;
2082     convert_VkPhysicalDeviceProperties_host_to_win(&in->properties, &out->properties);
2083 }
2084 #endif /* USE_STRUCT_CONVERSION */
2085
2086 #if defined(USE_STRUCT_CONVERSION)
2087 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(const VkPhysicalDeviceSurfaceInfo2KHR *in, VkPhysicalDeviceSurfaceInfo2KHR_host *out)
2088 #else
2089 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(const VkPhysicalDeviceSurfaceInfo2KHR *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
2090 #endif /* USE_STRUCT_CONVERSION */
2091 {
2092     if (!in) return;
2093
2094     out->sType = in->sType;
2095     out->pNext = in->pNext;
2096     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
2097 }
2098
2099 #if defined(USE_STRUCT_CONVERSION)
2100 static inline void convert_VkPipelineExecutableInfoKHR_win_to_host(const VkPipelineExecutableInfoKHR *in, VkPipelineExecutableInfoKHR_host *out)
2101 {
2102     if (!in) return;
2103
2104     out->sType = in->sType;
2105     out->pNext = in->pNext;
2106     out->pipeline = in->pipeline;
2107     out->executableIndex = in->executableIndex;
2108 }
2109 #endif /* USE_STRUCT_CONVERSION */
2110
2111 #if defined(USE_STRUCT_CONVERSION)
2112 static inline void convert_VkPipelineInfoKHR_win_to_host(const VkPipelineInfoKHR *in, VkPipelineInfoKHR_host *out)
2113 {
2114     if (!in) return;
2115
2116     out->sType = in->sType;
2117     out->pNext = in->pNext;
2118     out->pipeline = in->pipeline;
2119 }
2120 #endif /* USE_STRUCT_CONVERSION */
2121
2122 #if defined(USE_STRUCT_CONVERSION)
2123 static inline VkSparseMemoryBind_host *convert_VkSparseMemoryBind_array_win_to_host(const VkSparseMemoryBind *in, uint32_t count)
2124 {
2125     VkSparseMemoryBind_host *out;
2126     unsigned int i;
2127
2128     if (!in) return NULL;
2129
2130     out = malloc(count * sizeof(*out));
2131     for (i = 0; i < count; i++)
2132     {
2133         out[i].resourceOffset = in[i].resourceOffset;
2134         out[i].size = in[i].size;
2135         out[i].memory = in[i].memory;
2136         out[i].memoryOffset = in[i].memoryOffset;
2137         out[i].flags = in[i].flags;
2138     }
2139
2140     return out;
2141 }
2142 #endif /* USE_STRUCT_CONVERSION */
2143
2144 #if defined(USE_STRUCT_CONVERSION)
2145 static inline void free_VkSparseMemoryBind_array(VkSparseMemoryBind_host *in, uint32_t count)
2146 {
2147     if (!in) return;
2148
2149     free(in);
2150 }
2151 #endif /* USE_STRUCT_CONVERSION */
2152
2153 #if defined(USE_STRUCT_CONVERSION)
2154 static inline VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo_array_win_to_host(const VkSparseBufferMemoryBindInfo *in, uint32_t count)
2155 {
2156     VkSparseBufferMemoryBindInfo_host *out;
2157     unsigned int i;
2158
2159     if (!in) return NULL;
2160
2161     out = malloc(count * sizeof(*out));
2162     for (i = 0; i < count; i++)
2163     {
2164         out[i].buffer = in[i].buffer;
2165         out[i].bindCount = in[i].bindCount;
2166         out[i].pBinds = convert_VkSparseMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
2167     }
2168
2169     return out;
2170 }
2171 #endif /* USE_STRUCT_CONVERSION */
2172
2173 #if defined(USE_STRUCT_CONVERSION)
2174 static inline void free_VkSparseBufferMemoryBindInfo_array(VkSparseBufferMemoryBindInfo_host *in, uint32_t count)
2175 {
2176     unsigned int i;
2177
2178     if (!in) return;
2179
2180     for (i = 0; i < count; i++)
2181     {
2182         free_VkSparseMemoryBind_array((VkSparseMemoryBind_host *)in[i].pBinds, in[i].bindCount);
2183     }
2184     free(in);
2185 }
2186 #endif /* USE_STRUCT_CONVERSION */
2187
2188 #if defined(USE_STRUCT_CONVERSION)
2189 static inline VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo_array_win_to_host(const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
2190 {
2191     VkSparseImageOpaqueMemoryBindInfo_host *out;
2192     unsigned int i;
2193
2194     if (!in) return NULL;
2195
2196     out = malloc(count * sizeof(*out));
2197     for (i = 0; i < count; i++)
2198     {
2199         out[i].image = in[i].image;
2200         out[i].bindCount = in[i].bindCount;
2201         out[i].pBinds = convert_VkSparseMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
2202     }
2203
2204     return out;
2205 }
2206 #endif /* USE_STRUCT_CONVERSION */
2207
2208 #if defined(USE_STRUCT_CONVERSION)
2209 static inline void free_VkSparseImageOpaqueMemoryBindInfo_array(VkSparseImageOpaqueMemoryBindInfo_host *in, uint32_t count)
2210 {
2211     unsigned int i;
2212
2213     if (!in) return;
2214
2215     for (i = 0; i < count; i++)
2216     {
2217         free_VkSparseMemoryBind_array((VkSparseMemoryBind_host *)in[i].pBinds, in[i].bindCount);
2218     }
2219     free(in);
2220 }
2221 #endif /* USE_STRUCT_CONVERSION */
2222
2223 #if defined(USE_STRUCT_CONVERSION)
2224 static inline VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind_array_win_to_host(const VkSparseImageMemoryBind *in, uint32_t count)
2225 {
2226     VkSparseImageMemoryBind_host *out;
2227     unsigned int i;
2228
2229     if (!in) return NULL;
2230
2231     out = malloc(count * sizeof(*out));
2232     for (i = 0; i < count; i++)
2233     {
2234         out[i].subresource = in[i].subresource;
2235         out[i].offset = in[i].offset;
2236         out[i].extent = in[i].extent;
2237         out[i].memory = in[i].memory;
2238         out[i].memoryOffset = in[i].memoryOffset;
2239         out[i].flags = in[i].flags;
2240     }
2241
2242     return out;
2243 }
2244 #endif /* USE_STRUCT_CONVERSION */
2245
2246 #if defined(USE_STRUCT_CONVERSION)
2247 static inline void free_VkSparseImageMemoryBind_array(VkSparseImageMemoryBind_host *in, uint32_t count)
2248 {
2249     if (!in) return;
2250
2251     free(in);
2252 }
2253 #endif /* USE_STRUCT_CONVERSION */
2254
2255 #if defined(USE_STRUCT_CONVERSION)
2256 static inline VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo_array_win_to_host(const VkSparseImageMemoryBindInfo *in, uint32_t count)
2257 {
2258     VkSparseImageMemoryBindInfo_host *out;
2259     unsigned int i;
2260
2261     if (!in) return NULL;
2262
2263     out = malloc(count * sizeof(*out));
2264     for (i = 0; i < count; i++)
2265     {
2266         out[i].image = in[i].image;
2267         out[i].bindCount = in[i].bindCount;
2268         out[i].pBinds = convert_VkSparseImageMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
2269     }
2270
2271     return out;
2272 }
2273 #endif /* USE_STRUCT_CONVERSION */
2274
2275 #if defined(USE_STRUCT_CONVERSION)
2276 static inline void free_VkSparseImageMemoryBindInfo_array(VkSparseImageMemoryBindInfo_host *in, uint32_t count)
2277 {
2278     unsigned int i;
2279
2280     if (!in) return;
2281
2282     for (i = 0; i < count; i++)
2283     {
2284         free_VkSparseImageMemoryBind_array((VkSparseImageMemoryBind_host *)in[i].pBinds, in[i].bindCount);
2285     }
2286     free(in);
2287 }
2288 #endif /* USE_STRUCT_CONVERSION */
2289
2290 #if defined(USE_STRUCT_CONVERSION)
2291 static inline VkBindSparseInfo_host *convert_VkBindSparseInfo_array_win_to_host(const VkBindSparseInfo *in, uint32_t count)
2292 {
2293     VkBindSparseInfo_host *out;
2294     unsigned int i;
2295
2296     if (!in) return NULL;
2297
2298     out = malloc(count * sizeof(*out));
2299     for (i = 0; i < count; i++)
2300     {
2301         out[i].sType = in[i].sType;
2302         out[i].pNext = in[i].pNext;
2303         out[i].waitSemaphoreCount = in[i].waitSemaphoreCount;
2304         out[i].pWaitSemaphores = in[i].pWaitSemaphores;
2305         out[i].bufferBindCount = in[i].bufferBindCount;
2306         out[i].pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win_to_host(in[i].pBufferBinds, in[i].bufferBindCount);
2307         out[i].imageOpaqueBindCount = in[i].imageOpaqueBindCount;
2308         out[i].pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win_to_host(in[i].pImageOpaqueBinds, in[i].imageOpaqueBindCount);
2309         out[i].imageBindCount = in[i].imageBindCount;
2310         out[i].pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win_to_host(in[i].pImageBinds, in[i].imageBindCount);
2311         out[i].signalSemaphoreCount = in[i].signalSemaphoreCount;
2312         out[i].pSignalSemaphores = in[i].pSignalSemaphores;
2313     }
2314
2315     return out;
2316 }
2317 #endif /* USE_STRUCT_CONVERSION */
2318
2319 #if defined(USE_STRUCT_CONVERSION)
2320 static inline void free_VkBindSparseInfo_array(VkBindSparseInfo_host *in, uint32_t count)
2321 {
2322     unsigned int i;
2323
2324     if (!in) return;
2325
2326     for (i = 0; i < count; i++)
2327     {
2328         free_VkSparseBufferMemoryBindInfo_array((VkSparseBufferMemoryBindInfo_host *)in[i].pBufferBinds, in[i].bufferBindCount);
2329         free_VkSparseImageOpaqueMemoryBindInfo_array((VkSparseImageOpaqueMemoryBindInfo_host *)in[i].pImageOpaqueBinds, in[i].imageOpaqueBindCount);
2330         free_VkSparseImageMemoryBindInfo_array((VkSparseImageMemoryBindInfo_host *)in[i].pImageBinds, in[i].imageBindCount);
2331     }
2332     free(in);
2333 }
2334 #endif /* USE_STRUCT_CONVERSION */
2335
2336 static inline VkSubmitInfo *convert_VkSubmitInfo_array_win_to_host(const VkSubmitInfo *in, uint32_t count)
2337 {
2338     VkSubmitInfo *out;
2339     unsigned int i;
2340
2341     if (!in) return NULL;
2342
2343     out = malloc(count * sizeof(*out));
2344     for (i = 0; i < count; i++)
2345     {
2346         out[i].sType = in[i].sType;
2347         out[i].pNext = in[i].pNext;
2348         out[i].waitSemaphoreCount = in[i].waitSemaphoreCount;
2349         out[i].pWaitSemaphores = in[i].pWaitSemaphores;
2350         out[i].pWaitDstStageMask = in[i].pWaitDstStageMask;
2351         out[i].commandBufferCount = in[i].commandBufferCount;
2352         out[i].pCommandBuffers = convert_VkCommandBuffer_array_win_to_host(in[i].pCommandBuffers, in[i].commandBufferCount);
2353         out[i].signalSemaphoreCount = in[i].signalSemaphoreCount;
2354         out[i].pSignalSemaphores = in[i].pSignalSemaphores;
2355     }
2356
2357     return out;
2358 }
2359
2360 static inline void free_VkSubmitInfo_array(VkSubmitInfo *in, uint32_t count)
2361 {
2362     unsigned int i;
2363
2364     if (!in) return;
2365
2366     for (i = 0; i < count; i++)
2367     {
2368         free_VkCommandBuffer_array((VkCommandBuffer *)in[i].pCommandBuffers, in[i].commandBufferCount);
2369     }
2370     free(in);
2371 }
2372
2373 #if defined(USE_STRUCT_CONVERSION)
2374 static inline VkSemaphoreSubmitInfoKHR_host *convert_VkSemaphoreSubmitInfoKHR_array_win_to_host(const VkSemaphoreSubmitInfoKHR *in, uint32_t count)
2375 {
2376     VkSemaphoreSubmitInfoKHR_host *out;
2377     unsigned int i;
2378
2379     if (!in) return NULL;
2380
2381     out = malloc(count * sizeof(*out));
2382     for (i = 0; i < count; i++)
2383     {
2384         out[i].sType = in[i].sType;
2385         out[i].pNext = in[i].pNext;
2386         out[i].semaphore = in[i].semaphore;
2387         out[i].value = in[i].value;
2388         out[i].stageMask = in[i].stageMask;
2389         out[i].deviceIndex = in[i].deviceIndex;
2390     }
2391
2392     return out;
2393 }
2394 #endif /* USE_STRUCT_CONVERSION */
2395
2396 #if defined(USE_STRUCT_CONVERSION)
2397 static inline void free_VkSemaphoreSubmitInfoKHR_array(VkSemaphoreSubmitInfoKHR_host *in, uint32_t count)
2398 {
2399     if (!in) return;
2400
2401     free(in);
2402 }
2403 #endif /* USE_STRUCT_CONVERSION */
2404
2405 static inline VkCommandBufferSubmitInfoKHR *convert_VkCommandBufferSubmitInfoKHR_array_win_to_host(const VkCommandBufferSubmitInfoKHR *in, uint32_t count)
2406 {
2407     VkCommandBufferSubmitInfoKHR *out;
2408     unsigned int i;
2409
2410     if (!in) return NULL;
2411
2412     out = malloc(count * sizeof(*out));
2413     for (i = 0; i < count; i++)
2414     {
2415         out[i].sType = in[i].sType;
2416         out[i].pNext = in[i].pNext;
2417         out[i].commandBuffer = in[i].commandBuffer->command_buffer;
2418         out[i].deviceMask = in[i].deviceMask;
2419     }
2420
2421     return out;
2422 }
2423
2424 static inline void free_VkCommandBufferSubmitInfoKHR_array(VkCommandBufferSubmitInfoKHR *in, uint32_t count)
2425 {
2426     if (!in) return;
2427
2428     free(in);
2429 }
2430
2431 #if defined(USE_STRUCT_CONVERSION)
2432 static inline VkSubmitInfo2KHR_host *convert_VkSubmitInfo2KHR_array_win_to_host(const VkSubmitInfo2KHR *in, uint32_t count)
2433 {
2434     VkSubmitInfo2KHR_host *out;
2435 #else
2436 static inline VkSubmitInfo2KHR *convert_VkSubmitInfo2KHR_array_win_to_host(const VkSubmitInfo2KHR *in, uint32_t count)
2437 {
2438     VkSubmitInfo2KHR *out;
2439 #endif /* USE_STRUCT_CONVERSION */
2440     unsigned int i;
2441
2442     if (!in) return NULL;
2443
2444     out = malloc(count * sizeof(*out));
2445     for (i = 0; i < count; i++)
2446     {
2447         out[i].sType = in[i].sType;
2448         out[i].pNext = in[i].pNext;
2449         out[i].flags = in[i].flags;
2450         out[i].waitSemaphoreInfoCount = in[i].waitSemaphoreInfoCount;
2451 #if defined(USE_STRUCT_CONVERSION)
2452         out[i].pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfoKHR_array_win_to_host(in[i].pWaitSemaphoreInfos, in[i].waitSemaphoreInfoCount);
2453 #else
2454         out[i].pWaitSemaphoreInfos = in[i].pWaitSemaphoreInfos;
2455 #endif /* USE_STRUCT_CONVERSION */
2456         out[i].commandBufferInfoCount = in[i].commandBufferInfoCount;
2457         out[i].pCommandBufferInfos = convert_VkCommandBufferSubmitInfoKHR_array_win_to_host(in[i].pCommandBufferInfos, in[i].commandBufferInfoCount);
2458         out[i].signalSemaphoreInfoCount = in[i].signalSemaphoreInfoCount;
2459 #if defined(USE_STRUCT_CONVERSION)
2460         out[i].pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfoKHR_array_win_to_host(in[i].pSignalSemaphoreInfos, in[i].signalSemaphoreInfoCount);
2461 #else
2462         out[i].pSignalSemaphoreInfos = in[i].pSignalSemaphoreInfos;
2463 #endif /* USE_STRUCT_CONVERSION */
2464     }
2465
2466     return out;
2467 }
2468
2469 #if defined(USE_STRUCT_CONVERSION)
2470 static inline void free_VkSubmitInfo2KHR_array(VkSubmitInfo2KHR_host *in, uint32_t count)
2471 #else
2472 static inline void free_VkSubmitInfo2KHR_array(VkSubmitInfo2KHR *in, uint32_t count)
2473 #endif /* USE_STRUCT_CONVERSION */
2474 {
2475     unsigned int i;
2476
2477     if (!in) return;
2478
2479     for (i = 0; i < count; i++)
2480     {
2481 #if defined(USE_STRUCT_CONVERSION)
2482         free_VkSemaphoreSubmitInfoKHR_array((VkSemaphoreSubmitInfoKHR_host *)in[i].pWaitSemaphoreInfos, in[i].waitSemaphoreInfoCount);
2483 #endif /* USE_STRUCT_CONVERSION */
2484         free_VkCommandBufferSubmitInfoKHR_array((VkCommandBufferSubmitInfoKHR *)in[i].pCommandBufferInfos, in[i].commandBufferInfoCount);
2485 #if defined(USE_STRUCT_CONVERSION)
2486         free_VkSemaphoreSubmitInfoKHR_array((VkSemaphoreSubmitInfoKHR_host *)in[i].pSignalSemaphoreInfos, in[i].signalSemaphoreInfoCount);
2487 #endif /* USE_STRUCT_CONVERSION */
2488     }
2489     free(in);
2490 }
2491
2492 #if defined(USE_STRUCT_CONVERSION)
2493 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT_host *out)
2494 #else
2495 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out)
2496 #endif /* USE_STRUCT_CONVERSION */
2497 {
2498     if (!in) return;
2499
2500     out->sType = in->sType;
2501     out->pNext = in->pNext;
2502     out->objectType = in->objectType;
2503     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
2504     out->pObjectName = in->pObjectName;
2505 }
2506
2507 #if defined(USE_STRUCT_CONVERSION)
2508 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT_host *out)
2509 #else
2510 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out)
2511 #endif /* USE_STRUCT_CONVERSION */
2512 {
2513     if (!in) return;
2514
2515     out->sType = in->sType;
2516     out->pNext = in->pNext;
2517     out->objectType = in->objectType;
2518     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
2519     out->tagName = in->tagName;
2520     out->tagSize = in->tagSize;
2521     out->pTag = in->pTag;
2522 }
2523
2524 #if defined(USE_STRUCT_CONVERSION)
2525 static inline void convert_VkSemaphoreSignalInfo_win_to_host(const VkSemaphoreSignalInfo *in, VkSemaphoreSignalInfo_host *out)
2526 {
2527     if (!in) return;
2528
2529     out->sType = in->sType;
2530     out->pNext = in->pNext;
2531     out->semaphore = in->semaphore;
2532     out->value = in->value;
2533 }
2534 #endif /* USE_STRUCT_CONVERSION */
2535
2536 #if defined(USE_STRUCT_CONVERSION)
2537 static inline VkDebugUtilsObjectNameInfoEXT_host *convert_VkDebugUtilsObjectNameInfoEXT_array_win_to_host(const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
2538 {
2539     VkDebugUtilsObjectNameInfoEXT_host *out;
2540 #else
2541 static inline VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win_to_host(const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
2542 {
2543     VkDebugUtilsObjectNameInfoEXT *out;
2544 #endif /* USE_STRUCT_CONVERSION */
2545     unsigned int i;
2546
2547     if (!in) return NULL;
2548
2549     out = malloc(count * sizeof(*out));
2550     for (i = 0; i < count; i++)
2551     {
2552         out[i].sType = in[i].sType;
2553         out[i].pNext = in[i].pNext;
2554         out[i].objectType = in[i].objectType;
2555         out[i].objectHandle = wine_vk_unwrap_handle(in[i].objectType, in[i].objectHandle);
2556         out[i].pObjectName = in[i].pObjectName;
2557     }
2558
2559     return out;
2560 }
2561
2562 #if defined(USE_STRUCT_CONVERSION)
2563 static inline void free_VkDebugUtilsObjectNameInfoEXT_array(VkDebugUtilsObjectNameInfoEXT_host *in, uint32_t count)
2564 #else
2565 static inline void free_VkDebugUtilsObjectNameInfoEXT_array(VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
2566 #endif /* USE_STRUCT_CONVERSION */
2567 {
2568     if (!in) return;
2569
2570     free(in);
2571 }
2572
2573 #if defined(USE_STRUCT_CONVERSION)
2574 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win_to_host(const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT_host *out)
2575 #else
2576 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win_to_host(const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out)
2577 #endif /* USE_STRUCT_CONVERSION */
2578 {
2579     if (!in) return;
2580
2581     out->sType = in->sType;
2582     out->pNext = in->pNext;
2583     out->flags = in->flags;
2584     out->pMessageIdName = in->pMessageIdName;
2585     out->messageIdNumber = in->messageIdNumber;
2586     out->pMessage = in->pMessage;
2587     out->queueLabelCount = in->queueLabelCount;
2588     out->pQueueLabels = in->pQueueLabels;
2589     out->cmdBufLabelCount = in->cmdBufLabelCount;
2590     out->pCmdBufLabels = in->pCmdBufLabels;
2591     out->objectCount = in->objectCount;
2592     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win_to_host(in->pObjects, in->objectCount);
2593 }
2594
2595 #if defined(USE_STRUCT_CONVERSION)
2596 static inline void free_VkDebugUtilsMessengerCallbackDataEXT(VkDebugUtilsMessengerCallbackDataEXT_host *in)
2597 #else
2598 static inline void free_VkDebugUtilsMessengerCallbackDataEXT(VkDebugUtilsMessengerCallbackDataEXT *in)
2599 #endif /* USE_STRUCT_CONVERSION */
2600 {
2601 #if defined(USE_STRUCT_CONVERSION)
2602     free_VkDebugUtilsObjectNameInfoEXT_array((VkDebugUtilsObjectNameInfoEXT_host *)in->pObjects, in->objectCount);
2603 #else
2604     free_VkDebugUtilsObjectNameInfoEXT_array((VkDebugUtilsObjectNameInfoEXT *)in->pObjects, in->objectCount);
2605 #endif /* USE_STRUCT_CONVERSION */
2606 }
2607
2608 #if defined(USE_STRUCT_CONVERSION)
2609 static inline VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array_win_to_host(const VkCopyDescriptorSet *in, uint32_t count)
2610 {
2611     VkCopyDescriptorSet_host *out;
2612     unsigned int i;
2613
2614     if (!in) return NULL;
2615
2616     out = malloc(count * sizeof(*out));
2617     for (i = 0; i < count; i++)
2618     {
2619         out[i].sType = in[i].sType;
2620         out[i].pNext = in[i].pNext;
2621         out[i].srcSet = in[i].srcSet;
2622         out[i].srcBinding = in[i].srcBinding;
2623         out[i].srcArrayElement = in[i].srcArrayElement;
2624         out[i].dstSet = in[i].dstSet;
2625         out[i].dstBinding = in[i].dstBinding;
2626         out[i].dstArrayElement = in[i].dstArrayElement;
2627         out[i].descriptorCount = in[i].descriptorCount;
2628     }
2629
2630     return out;
2631 }
2632 #endif /* USE_STRUCT_CONVERSION */
2633
2634 #if defined(USE_STRUCT_CONVERSION)
2635 static inline void free_VkCopyDescriptorSet_array(VkCopyDescriptorSet_host *in, uint32_t count)
2636 {
2637     if (!in) return;
2638
2639     free(in);
2640 }
2641 #endif /* USE_STRUCT_CONVERSION */
2642
2643 static inline VkPhysicalDevice *convert_VkPhysicalDevice_array_win_to_host(const VkPhysicalDevice *in, uint32_t count)
2644 {
2645     VkPhysicalDevice *out;
2646     unsigned int i;
2647
2648     if (!in) return NULL;
2649
2650     out = malloc(count * sizeof(*out));
2651     for (i = 0; i < count; i++)
2652     {
2653         out[i] = in[i]->phys_dev;
2654     }
2655
2656     return out;
2657 }
2658
2659 static inline void free_VkPhysicalDevice_array(VkPhysicalDevice *in, uint32_t count)
2660 {
2661     if (!in) return;
2662
2663     free(in);
2664 }
2665
2666 VkResult convert_VkDeviceCreateInfo_struct_chain(const void *pNext, VkDeviceCreateInfo *out_struct)
2667 {
2668     VkBaseOutStructure *out_header = (VkBaseOutStructure *)out_struct;
2669     const VkBaseInStructure *in_header;
2670
2671     out_header->pNext = NULL;
2672
2673     for (in_header = pNext; in_header; in_header = in_header->pNext)
2674     {
2675         switch (in_header->sType)
2676         {
2677         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
2678             break;
2679
2680         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
2681         {
2682             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
2683             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out;
2684
2685             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2686
2687             out->sType = in->sType;
2688             out->pNext = NULL;
2689             out->deviceGeneratedCommands = in->deviceGeneratedCommands;
2690
2691             out_header->pNext = (VkBaseOutStructure *)out;
2692             out_header = out_header->pNext;
2693             break;
2694         }
2695
2696         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
2697         {
2698             const VkDevicePrivateDataCreateInfoEXT *in = (const VkDevicePrivateDataCreateInfoEXT *)in_header;
2699             VkDevicePrivateDataCreateInfoEXT *out;
2700
2701             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2702
2703             out->sType = in->sType;
2704             out->pNext = NULL;
2705             out->privateDataSlotRequestCount = in->privateDataSlotRequestCount;
2706
2707             out_header->pNext = (VkBaseOutStructure *)out;
2708             out_header = out_header->pNext;
2709             break;
2710         }
2711
2712         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
2713         {
2714             const VkPhysicalDevicePrivateDataFeaturesEXT *in = (const VkPhysicalDevicePrivateDataFeaturesEXT *)in_header;
2715             VkPhysicalDevicePrivateDataFeaturesEXT *out;
2716
2717             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2718
2719             out->sType = in->sType;
2720             out->pNext = NULL;
2721             out->privateData = in->privateData;
2722
2723             out_header->pNext = (VkBaseOutStructure *)out;
2724             out_header = out_header->pNext;
2725             break;
2726         }
2727
2728         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
2729         {
2730             const VkPhysicalDeviceFeatures2 *in = (const VkPhysicalDeviceFeatures2 *)in_header;
2731             VkPhysicalDeviceFeatures2 *out;
2732
2733             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2734
2735             out->sType = in->sType;
2736             out->pNext = NULL;
2737             out->features = in->features;
2738
2739             out_header->pNext = (VkBaseOutStructure *)out;
2740             out_header = out_header->pNext;
2741             break;
2742         }
2743
2744         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
2745         {
2746             const VkPhysicalDeviceVariablePointersFeatures *in = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
2747             VkPhysicalDeviceVariablePointersFeatures *out;
2748
2749             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2750
2751             out->sType = in->sType;
2752             out->pNext = NULL;
2753             out->variablePointersStorageBuffer = in->variablePointersStorageBuffer;
2754             out->variablePointers = in->variablePointers;
2755
2756             out_header->pNext = (VkBaseOutStructure *)out;
2757             out_header = out_header->pNext;
2758             break;
2759         }
2760
2761         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
2762         {
2763             const VkPhysicalDeviceMultiviewFeatures *in = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
2764             VkPhysicalDeviceMultiviewFeatures *out;
2765
2766             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2767
2768             out->sType = in->sType;
2769             out->pNext = NULL;
2770             out->multiview = in->multiview;
2771             out->multiviewGeometryShader = in->multiviewGeometryShader;
2772             out->multiviewTessellationShader = in->multiviewTessellationShader;
2773
2774             out_header->pNext = (VkBaseOutStructure *)out;
2775             out_header = out_header->pNext;
2776             break;
2777         }
2778
2779         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
2780         {
2781             const VkDeviceGroupDeviceCreateInfo *in = (const VkDeviceGroupDeviceCreateInfo *)in_header;
2782             VkDeviceGroupDeviceCreateInfo *out;
2783
2784             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2785
2786             out->sType = in->sType;
2787             out->pNext = NULL;
2788             out->physicalDeviceCount = in->physicalDeviceCount;
2789             out->pPhysicalDevices = convert_VkPhysicalDevice_array_win_to_host(in->pPhysicalDevices, in->physicalDeviceCount);
2790
2791             out_header->pNext = (VkBaseOutStructure *)out;
2792             out_header = out_header->pNext;
2793             break;
2794         }
2795
2796         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
2797         {
2798             const VkPhysicalDevicePresentIdFeaturesKHR *in = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
2799             VkPhysicalDevicePresentIdFeaturesKHR *out;
2800
2801             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2802
2803             out->sType = in->sType;
2804             out->pNext = NULL;
2805             out->presentId = in->presentId;
2806
2807             out_header->pNext = (VkBaseOutStructure *)out;
2808             out_header = out_header->pNext;
2809             break;
2810         }
2811
2812         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
2813         {
2814             const VkPhysicalDevicePresentWaitFeaturesKHR *in = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
2815             VkPhysicalDevicePresentWaitFeaturesKHR *out;
2816
2817             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2818
2819             out->sType = in->sType;
2820             out->pNext = NULL;
2821             out->presentWait = in->presentWait;
2822
2823             out_header->pNext = (VkBaseOutStructure *)out;
2824             out_header = out_header->pNext;
2825             break;
2826         }
2827
2828         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
2829         {
2830             const VkPhysicalDevice16BitStorageFeatures *in = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
2831             VkPhysicalDevice16BitStorageFeatures *out;
2832
2833             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2834
2835             out->sType = in->sType;
2836             out->pNext = NULL;
2837             out->storageBuffer16BitAccess = in->storageBuffer16BitAccess;
2838             out->uniformAndStorageBuffer16BitAccess = in->uniformAndStorageBuffer16BitAccess;
2839             out->storagePushConstant16 = in->storagePushConstant16;
2840             out->storageInputOutput16 = in->storageInputOutput16;
2841
2842             out_header->pNext = (VkBaseOutStructure *)out;
2843             out_header = out_header->pNext;
2844             break;
2845         }
2846
2847         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
2848         {
2849             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
2850             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out;
2851
2852             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2853
2854             out->sType = in->sType;
2855             out->pNext = NULL;
2856             out->shaderSubgroupExtendedTypes = in->shaderSubgroupExtendedTypes;
2857
2858             out_header->pNext = (VkBaseOutStructure *)out;
2859             out_header = out_header->pNext;
2860             break;
2861         }
2862
2863         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
2864         {
2865             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
2866             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out;
2867
2868             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2869
2870             out->sType = in->sType;
2871             out->pNext = NULL;
2872             out->samplerYcbcrConversion = in->samplerYcbcrConversion;
2873
2874             out_header->pNext = (VkBaseOutStructure *)out;
2875             out_header = out_header->pNext;
2876             break;
2877         }
2878
2879         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
2880         {
2881             const VkPhysicalDeviceProtectedMemoryFeatures *in = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
2882             VkPhysicalDeviceProtectedMemoryFeatures *out;
2883
2884             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2885
2886             out->sType = in->sType;
2887             out->pNext = NULL;
2888             out->protectedMemory = in->protectedMemory;
2889
2890             out_header->pNext = (VkBaseOutStructure *)out;
2891             out_header = out_header->pNext;
2892             break;
2893         }
2894
2895         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
2896         {
2897             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
2898             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out;
2899
2900             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2901
2902             out->sType = in->sType;
2903             out->pNext = NULL;
2904             out->advancedBlendCoherentOperations = in->advancedBlendCoherentOperations;
2905
2906             out_header->pNext = (VkBaseOutStructure *)out;
2907             out_header = out_header->pNext;
2908             break;
2909         }
2910
2911         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
2912         {
2913             const VkPhysicalDeviceMultiDrawFeaturesEXT *in = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
2914             VkPhysicalDeviceMultiDrawFeaturesEXT *out;
2915
2916             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2917
2918             out->sType = in->sType;
2919             out->pNext = NULL;
2920             out->multiDraw = in->multiDraw;
2921
2922             out_header->pNext = (VkBaseOutStructure *)out;
2923             out_header = out_header->pNext;
2924             break;
2925         }
2926
2927         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
2928         {
2929             const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *in = (const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *)in_header;
2930             VkPhysicalDeviceInlineUniformBlockFeaturesEXT *out;
2931
2932             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2933
2934             out->sType = in->sType;
2935             out->pNext = NULL;
2936             out->inlineUniformBlock = in->inlineUniformBlock;
2937             out->descriptorBindingInlineUniformBlockUpdateAfterBind = in->descriptorBindingInlineUniformBlockUpdateAfterBind;
2938
2939             out_header->pNext = (VkBaseOutStructure *)out;
2940             out_header = out_header->pNext;
2941             break;
2942         }
2943
2944         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
2945         {
2946             const VkPhysicalDeviceShaderDrawParametersFeatures *in = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
2947             VkPhysicalDeviceShaderDrawParametersFeatures *out;
2948
2949             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2950
2951             out->sType = in->sType;
2952             out->pNext = NULL;
2953             out->shaderDrawParameters = in->shaderDrawParameters;
2954
2955             out_header->pNext = (VkBaseOutStructure *)out;
2956             out_header = out_header->pNext;
2957             break;
2958         }
2959
2960         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
2961         {
2962             const VkPhysicalDeviceShaderFloat16Int8Features *in = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
2963             VkPhysicalDeviceShaderFloat16Int8Features *out;
2964
2965             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2966
2967             out->sType = in->sType;
2968             out->pNext = NULL;
2969             out->shaderFloat16 = in->shaderFloat16;
2970             out->shaderInt8 = in->shaderInt8;
2971
2972             out_header->pNext = (VkBaseOutStructure *)out;
2973             out_header = out_header->pNext;
2974             break;
2975         }
2976
2977         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
2978         {
2979             const VkPhysicalDeviceHostQueryResetFeatures *in = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
2980             VkPhysicalDeviceHostQueryResetFeatures *out;
2981
2982             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2983
2984             out->sType = in->sType;
2985             out->pNext = NULL;
2986             out->hostQueryReset = in->hostQueryReset;
2987
2988             out_header->pNext = (VkBaseOutStructure *)out;
2989             out_header = out_header->pNext;
2990             break;
2991         }
2992
2993         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
2994         {
2995             const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT *in = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT *)in_header;
2996             VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT *out;
2997
2998             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
2999
3000             out->sType = in->sType;
3001             out->pNext = NULL;
3002             out->globalPriorityQuery = in->globalPriorityQuery;
3003
3004             out_header->pNext = (VkBaseOutStructure *)out;
3005             out_header = out_header->pNext;
3006             break;
3007         }
3008
3009         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
3010         {
3011             const VkPhysicalDeviceDescriptorIndexingFeatures *in = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
3012             VkPhysicalDeviceDescriptorIndexingFeatures *out;
3013
3014             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3015
3016             out->sType = in->sType;
3017             out->pNext = NULL;
3018             out->shaderInputAttachmentArrayDynamicIndexing = in->shaderInputAttachmentArrayDynamicIndexing;
3019             out->shaderUniformTexelBufferArrayDynamicIndexing = in->shaderUniformTexelBufferArrayDynamicIndexing;
3020             out->shaderStorageTexelBufferArrayDynamicIndexing = in->shaderStorageTexelBufferArrayDynamicIndexing;
3021             out->shaderUniformBufferArrayNonUniformIndexing = in->shaderUniformBufferArrayNonUniformIndexing;
3022             out->shaderSampledImageArrayNonUniformIndexing = in->shaderSampledImageArrayNonUniformIndexing;
3023             out->shaderStorageBufferArrayNonUniformIndexing = in->shaderStorageBufferArrayNonUniformIndexing;
3024             out->shaderStorageImageArrayNonUniformIndexing = in->shaderStorageImageArrayNonUniformIndexing;
3025             out->shaderInputAttachmentArrayNonUniformIndexing = in->shaderInputAttachmentArrayNonUniformIndexing;
3026             out->shaderUniformTexelBufferArrayNonUniformIndexing = in->shaderUniformTexelBufferArrayNonUniformIndexing;
3027             out->shaderStorageTexelBufferArrayNonUniformIndexing = in->shaderStorageTexelBufferArrayNonUniformIndexing;
3028             out->descriptorBindingUniformBufferUpdateAfterBind = in->descriptorBindingUniformBufferUpdateAfterBind;
3029             out->descriptorBindingSampledImageUpdateAfterBind = in->descriptorBindingSampledImageUpdateAfterBind;
3030             out->descriptorBindingStorageImageUpdateAfterBind = in->descriptorBindingStorageImageUpdateAfterBind;
3031             out->descriptorBindingStorageBufferUpdateAfterBind = in->descriptorBindingStorageBufferUpdateAfterBind;
3032             out->descriptorBindingUniformTexelBufferUpdateAfterBind = in->descriptorBindingUniformTexelBufferUpdateAfterBind;
3033             out->descriptorBindingStorageTexelBufferUpdateAfterBind = in->descriptorBindingStorageTexelBufferUpdateAfterBind;
3034             out->descriptorBindingUpdateUnusedWhilePending = in->descriptorBindingUpdateUnusedWhilePending;
3035             out->descriptorBindingPartiallyBound = in->descriptorBindingPartiallyBound;
3036             out->descriptorBindingVariableDescriptorCount = in->descriptorBindingVariableDescriptorCount;
3037             out->runtimeDescriptorArray = in->runtimeDescriptorArray;
3038
3039             out_header->pNext = (VkBaseOutStructure *)out;
3040             out_header = out_header->pNext;
3041             break;
3042         }
3043
3044         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
3045         {
3046             const VkPhysicalDeviceTimelineSemaphoreFeatures *in = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
3047             VkPhysicalDeviceTimelineSemaphoreFeatures *out;
3048
3049             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3050
3051             out->sType = in->sType;
3052             out->pNext = NULL;
3053             out->timelineSemaphore = in->timelineSemaphore;
3054
3055             out_header->pNext = (VkBaseOutStructure *)out;
3056             out_header = out_header->pNext;
3057             break;
3058         }
3059
3060         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
3061         {
3062             const VkPhysicalDevice8BitStorageFeatures *in = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
3063             VkPhysicalDevice8BitStorageFeatures *out;
3064
3065             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3066
3067             out->sType = in->sType;
3068             out->pNext = NULL;
3069             out->storageBuffer8BitAccess = in->storageBuffer8BitAccess;
3070             out->uniformAndStorageBuffer8BitAccess = in->uniformAndStorageBuffer8BitAccess;
3071             out->storagePushConstant8 = in->storagePushConstant8;
3072
3073             out_header->pNext = (VkBaseOutStructure *)out;
3074             out_header = out_header->pNext;
3075             break;
3076         }
3077
3078         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
3079         {
3080             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
3081             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out;
3082
3083             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3084
3085             out->sType = in->sType;
3086             out->pNext = NULL;
3087             out->conditionalRendering = in->conditionalRendering;
3088             out->inheritedConditionalRendering = in->inheritedConditionalRendering;
3089
3090             out_header->pNext = (VkBaseOutStructure *)out;
3091             out_header = out_header->pNext;
3092             break;
3093         }
3094
3095         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
3096         {
3097             const VkPhysicalDeviceVulkanMemoryModelFeatures *in = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
3098             VkPhysicalDeviceVulkanMemoryModelFeatures *out;
3099
3100             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3101
3102             out->sType = in->sType;
3103             out->pNext = NULL;
3104             out->vulkanMemoryModel = in->vulkanMemoryModel;
3105             out->vulkanMemoryModelDeviceScope = in->vulkanMemoryModelDeviceScope;
3106             out->vulkanMemoryModelAvailabilityVisibilityChains = in->vulkanMemoryModelAvailabilityVisibilityChains;
3107
3108             out_header->pNext = (VkBaseOutStructure *)out;
3109             out_header = out_header->pNext;
3110             break;
3111         }
3112
3113         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
3114         {
3115             const VkPhysicalDeviceShaderAtomicInt64Features *in = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
3116             VkPhysicalDeviceShaderAtomicInt64Features *out;
3117
3118             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3119
3120             out->sType = in->sType;
3121             out->pNext = NULL;
3122             out->shaderBufferInt64Atomics = in->shaderBufferInt64Atomics;
3123             out->shaderSharedInt64Atomics = in->shaderSharedInt64Atomics;
3124
3125             out_header->pNext = (VkBaseOutStructure *)out;
3126             out_header = out_header->pNext;
3127             break;
3128         }
3129
3130         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
3131         {
3132             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
3133             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out;
3134
3135             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3136
3137             out->sType = in->sType;
3138             out->pNext = NULL;
3139             out->shaderBufferFloat32Atomics = in->shaderBufferFloat32Atomics;
3140             out->shaderBufferFloat32AtomicAdd = in->shaderBufferFloat32AtomicAdd;
3141             out->shaderBufferFloat64Atomics = in->shaderBufferFloat64Atomics;
3142             out->shaderBufferFloat64AtomicAdd = in->shaderBufferFloat64AtomicAdd;
3143             out->shaderSharedFloat32Atomics = in->shaderSharedFloat32Atomics;
3144             out->shaderSharedFloat32AtomicAdd = in->shaderSharedFloat32AtomicAdd;
3145             out->shaderSharedFloat64Atomics = in->shaderSharedFloat64Atomics;
3146             out->shaderSharedFloat64AtomicAdd = in->shaderSharedFloat64AtomicAdd;
3147             out->shaderImageFloat32Atomics = in->shaderImageFloat32Atomics;
3148             out->shaderImageFloat32AtomicAdd = in->shaderImageFloat32AtomicAdd;
3149             out->sparseImageFloat32Atomics = in->sparseImageFloat32Atomics;
3150             out->sparseImageFloat32AtomicAdd = in->sparseImageFloat32AtomicAdd;
3151
3152             out_header->pNext = (VkBaseOutStructure *)out;
3153             out_header = out_header->pNext;
3154             break;
3155         }
3156
3157         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
3158         {
3159             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
3160             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out;
3161
3162             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3163
3164             out->sType = in->sType;
3165             out->pNext = NULL;
3166             out->shaderBufferFloat16Atomics = in->shaderBufferFloat16Atomics;
3167             out->shaderBufferFloat16AtomicAdd = in->shaderBufferFloat16AtomicAdd;
3168             out->shaderBufferFloat16AtomicMinMax = in->shaderBufferFloat16AtomicMinMax;
3169             out->shaderBufferFloat32AtomicMinMax = in->shaderBufferFloat32AtomicMinMax;
3170             out->shaderBufferFloat64AtomicMinMax = in->shaderBufferFloat64AtomicMinMax;
3171             out->shaderSharedFloat16Atomics = in->shaderSharedFloat16Atomics;
3172             out->shaderSharedFloat16AtomicAdd = in->shaderSharedFloat16AtomicAdd;
3173             out->shaderSharedFloat16AtomicMinMax = in->shaderSharedFloat16AtomicMinMax;
3174             out->shaderSharedFloat32AtomicMinMax = in->shaderSharedFloat32AtomicMinMax;
3175             out->shaderSharedFloat64AtomicMinMax = in->shaderSharedFloat64AtomicMinMax;
3176             out->shaderImageFloat32AtomicMinMax = in->shaderImageFloat32AtomicMinMax;
3177             out->sparseImageFloat32AtomicMinMax = in->sparseImageFloat32AtomicMinMax;
3178
3179             out_header->pNext = (VkBaseOutStructure *)out;
3180             out_header = out_header->pNext;
3181             break;
3182         }
3183
3184         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
3185         {
3186             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
3187             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out;
3188
3189             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3190
3191             out->sType = in->sType;
3192             out->pNext = NULL;
3193             out->vertexAttributeInstanceRateDivisor = in->vertexAttributeInstanceRateDivisor;
3194             out->vertexAttributeInstanceRateZeroDivisor = in->vertexAttributeInstanceRateZeroDivisor;
3195
3196             out_header->pNext = (VkBaseOutStructure *)out;
3197             out_header = out_header->pNext;
3198             break;
3199         }
3200
3201         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
3202         {
3203             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
3204             VkPhysicalDeviceASTCDecodeFeaturesEXT *out;
3205
3206             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3207
3208             out->sType = in->sType;
3209             out->pNext = NULL;
3210             out->decodeModeSharedExponent = in->decodeModeSharedExponent;
3211
3212             out_header->pNext = (VkBaseOutStructure *)out;
3213             out_header = out_header->pNext;
3214             break;
3215         }
3216
3217         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
3218         {
3219             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
3220             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out;
3221
3222             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3223
3224             out->sType = in->sType;
3225             out->pNext = NULL;
3226             out->transformFeedback = in->transformFeedback;
3227             out->geometryStreams = in->geometryStreams;
3228
3229             out_header->pNext = (VkBaseOutStructure *)out;
3230             out_header = out_header->pNext;
3231             break;
3232         }
3233
3234         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
3235         {
3236             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
3237             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out;
3238
3239             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3240
3241             out->sType = in->sType;
3242             out->pNext = NULL;
3243             out->representativeFragmentTest = in->representativeFragmentTest;
3244
3245             out_header->pNext = (VkBaseOutStructure *)out;
3246             out_header = out_header->pNext;
3247             break;
3248         }
3249
3250         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
3251         {
3252             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
3253             VkPhysicalDeviceExclusiveScissorFeaturesNV *out;
3254
3255             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3256
3257             out->sType = in->sType;
3258             out->pNext = NULL;
3259             out->exclusiveScissor = in->exclusiveScissor;
3260
3261             out_header->pNext = (VkBaseOutStructure *)out;
3262             out_header = out_header->pNext;
3263             break;
3264         }
3265
3266         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
3267         {
3268             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
3269             VkPhysicalDeviceCornerSampledImageFeaturesNV *out;
3270
3271             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3272
3273             out->sType = in->sType;
3274             out->pNext = NULL;
3275             out->cornerSampledImage = in->cornerSampledImage;
3276
3277             out_header->pNext = (VkBaseOutStructure *)out;
3278             out_header = out_header->pNext;
3279             break;
3280         }
3281
3282         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
3283         {
3284             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
3285             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out;
3286
3287             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3288
3289             out->sType = in->sType;
3290             out->pNext = NULL;
3291             out->computeDerivativeGroupQuads = in->computeDerivativeGroupQuads;
3292             out->computeDerivativeGroupLinear = in->computeDerivativeGroupLinear;
3293
3294             out_header->pNext = (VkBaseOutStructure *)out;
3295             out_header = out_header->pNext;
3296             break;
3297         }
3298
3299         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
3300         {
3301             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *in = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *)in_header;
3302             VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *out;
3303
3304             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3305
3306             out->sType = in->sType;
3307             out->pNext = NULL;
3308             out->fragmentShaderBarycentric = in->fragmentShaderBarycentric;
3309
3310             out_header->pNext = (VkBaseOutStructure *)out;
3311             out_header = out_header->pNext;
3312             break;
3313         }
3314
3315         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
3316         {
3317             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
3318             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out;
3319
3320             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3321
3322             out->sType = in->sType;
3323             out->pNext = NULL;
3324             out->imageFootprint = in->imageFootprint;
3325
3326             out_header->pNext = (VkBaseOutStructure *)out;
3327             out_header = out_header->pNext;
3328             break;
3329         }
3330
3331         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
3332         {
3333             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
3334             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out;
3335
3336             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3337
3338             out->sType = in->sType;
3339             out->pNext = NULL;
3340             out->dedicatedAllocationImageAliasing = in->dedicatedAllocationImageAliasing;
3341
3342             out_header->pNext = (VkBaseOutStructure *)out;
3343             out_header = out_header->pNext;
3344             break;
3345         }
3346
3347         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
3348         {
3349             const VkPhysicalDeviceShadingRateImageFeaturesNV *in = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
3350             VkPhysicalDeviceShadingRateImageFeaturesNV *out;
3351
3352             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3353
3354             out->sType = in->sType;
3355             out->pNext = NULL;
3356             out->shadingRateImage = in->shadingRateImage;
3357             out->shadingRateCoarseSampleOrder = in->shadingRateCoarseSampleOrder;
3358
3359             out_header->pNext = (VkBaseOutStructure *)out;
3360             out_header = out_header->pNext;
3361             break;
3362         }
3363
3364         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
3365         {
3366             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
3367             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out;
3368
3369             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3370
3371             out->sType = in->sType;
3372             out->pNext = NULL;
3373             out->invocationMask = in->invocationMask;
3374
3375             out_header->pNext = (VkBaseOutStructure *)out;
3376             out_header = out_header->pNext;
3377             break;
3378         }
3379
3380         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
3381         {
3382             const VkPhysicalDeviceMeshShaderFeaturesNV *in = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
3383             VkPhysicalDeviceMeshShaderFeaturesNV *out;
3384
3385             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3386
3387             out->sType = in->sType;
3388             out->pNext = NULL;
3389             out->taskShader = in->taskShader;
3390             out->meshShader = in->meshShader;
3391
3392             out_header->pNext = (VkBaseOutStructure *)out;
3393             out_header = out_header->pNext;
3394             break;
3395         }
3396
3397         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
3398         {
3399             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
3400             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out;
3401
3402             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3403
3404             out->sType = in->sType;
3405             out->pNext = NULL;
3406             out->accelerationStructure = in->accelerationStructure;
3407             out->accelerationStructureCaptureReplay = in->accelerationStructureCaptureReplay;
3408             out->accelerationStructureIndirectBuild = in->accelerationStructureIndirectBuild;
3409             out->accelerationStructureHostCommands = in->accelerationStructureHostCommands;
3410             out->descriptorBindingAccelerationStructureUpdateAfterBind = in->descriptorBindingAccelerationStructureUpdateAfterBind;
3411
3412             out_header->pNext = (VkBaseOutStructure *)out;
3413             out_header = out_header->pNext;
3414             break;
3415         }
3416
3417         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
3418         {
3419             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
3420             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out;
3421
3422             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3423
3424             out->sType = in->sType;
3425             out->pNext = NULL;
3426             out->rayTracingPipeline = in->rayTracingPipeline;
3427             out->rayTracingPipelineShaderGroupHandleCaptureReplay = in->rayTracingPipelineShaderGroupHandleCaptureReplay;
3428             out->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
3429             out->rayTracingPipelineTraceRaysIndirect = in->rayTracingPipelineTraceRaysIndirect;
3430             out->rayTraversalPrimitiveCulling = in->rayTraversalPrimitiveCulling;
3431
3432             out_header->pNext = (VkBaseOutStructure *)out;
3433             out_header = out_header->pNext;
3434             break;
3435         }
3436
3437         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
3438         {
3439             const VkPhysicalDeviceRayQueryFeaturesKHR *in = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
3440             VkPhysicalDeviceRayQueryFeaturesKHR *out;
3441
3442             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3443
3444             out->sType = in->sType;
3445             out->pNext = NULL;
3446             out->rayQuery = in->rayQuery;
3447
3448             out_header->pNext = (VkBaseOutStructure *)out;
3449             out_header = out_header->pNext;
3450             break;
3451         }
3452
3453         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
3454         {
3455             const VkDeviceMemoryOverallocationCreateInfoAMD *in = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
3456             VkDeviceMemoryOverallocationCreateInfoAMD *out;
3457
3458             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3459
3460             out->sType = in->sType;
3461             out->pNext = NULL;
3462             out->overallocationBehavior = in->overallocationBehavior;
3463
3464             out_header->pNext = (VkBaseOutStructure *)out;
3465             out_header = out_header->pNext;
3466             break;
3467         }
3468
3469         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
3470         {
3471             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
3472             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out;
3473
3474             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3475
3476             out->sType = in->sType;
3477             out->pNext = NULL;
3478             out->fragmentDensityMap = in->fragmentDensityMap;
3479             out->fragmentDensityMapDynamic = in->fragmentDensityMapDynamic;
3480             out->fragmentDensityMapNonSubsampledImages = in->fragmentDensityMapNonSubsampledImages;
3481
3482             out_header->pNext = (VkBaseOutStructure *)out;
3483             out_header = out_header->pNext;
3484             break;
3485         }
3486
3487         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
3488         {
3489             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
3490             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out;
3491
3492             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3493
3494             out->sType = in->sType;
3495             out->pNext = NULL;
3496             out->fragmentDensityMapDeferred = in->fragmentDensityMapDeferred;
3497
3498             out_header->pNext = (VkBaseOutStructure *)out;
3499             out_header = out_header->pNext;
3500             break;
3501         }
3502
3503         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
3504         {
3505             const VkPhysicalDeviceScalarBlockLayoutFeatures *in = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
3506             VkPhysicalDeviceScalarBlockLayoutFeatures *out;
3507
3508             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3509
3510             out->sType = in->sType;
3511             out->pNext = NULL;
3512             out->scalarBlockLayout = in->scalarBlockLayout;
3513
3514             out_header->pNext = (VkBaseOutStructure *)out;
3515             out_header = out_header->pNext;
3516             break;
3517         }
3518
3519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
3520         {
3521             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
3522             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out;
3523
3524             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3525
3526             out->sType = in->sType;
3527             out->pNext = NULL;
3528             out->uniformBufferStandardLayout = in->uniformBufferStandardLayout;
3529
3530             out_header->pNext = (VkBaseOutStructure *)out;
3531             out_header = out_header->pNext;
3532             break;
3533         }
3534
3535         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
3536         {
3537             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
3538             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out;
3539
3540             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3541
3542             out->sType = in->sType;
3543             out->pNext = NULL;
3544             out->depthClipEnable = in->depthClipEnable;
3545
3546             out_header->pNext = (VkBaseOutStructure *)out;
3547             out_header = out_header->pNext;
3548             break;
3549         }
3550
3551         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
3552         {
3553             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
3554             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out;
3555
3556             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3557
3558             out->sType = in->sType;
3559             out->pNext = NULL;
3560             out->memoryPriority = in->memoryPriority;
3561
3562             out_header->pNext = (VkBaseOutStructure *)out;
3563             out_header = out_header->pNext;
3564             break;
3565         }
3566
3567         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
3568         {
3569             const VkPhysicalDeviceBufferDeviceAddressFeatures *in = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
3570             VkPhysicalDeviceBufferDeviceAddressFeatures *out;
3571
3572             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3573
3574             out->sType = in->sType;
3575             out->pNext = NULL;
3576             out->bufferDeviceAddress = in->bufferDeviceAddress;
3577             out->bufferDeviceAddressCaptureReplay = in->bufferDeviceAddressCaptureReplay;
3578             out->bufferDeviceAddressMultiDevice = in->bufferDeviceAddressMultiDevice;
3579
3580             out_header->pNext = (VkBaseOutStructure *)out;
3581             out_header = out_header->pNext;
3582             break;
3583         }
3584
3585         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
3586         {
3587             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
3588             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out;
3589
3590             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3591
3592             out->sType = in->sType;
3593             out->pNext = NULL;
3594             out->bufferDeviceAddress = in->bufferDeviceAddress;
3595             out->bufferDeviceAddressCaptureReplay = in->bufferDeviceAddressCaptureReplay;
3596             out->bufferDeviceAddressMultiDevice = in->bufferDeviceAddressMultiDevice;
3597
3598             out_header->pNext = (VkBaseOutStructure *)out;
3599             out_header = out_header->pNext;
3600             break;
3601         }
3602
3603         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
3604         {
3605             const VkPhysicalDeviceImagelessFramebufferFeatures *in = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
3606             VkPhysicalDeviceImagelessFramebufferFeatures *out;
3607
3608             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3609
3610             out->sType = in->sType;
3611             out->pNext = NULL;
3612             out->imagelessFramebuffer = in->imagelessFramebuffer;
3613
3614             out_header->pNext = (VkBaseOutStructure *)out;
3615             out_header = out_header->pNext;
3616             break;
3617         }
3618
3619         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
3620         {
3621             const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *in = (const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *)in_header;
3622             VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *out;
3623
3624             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3625
3626             out->sType = in->sType;
3627             out->pNext = NULL;
3628             out->textureCompressionASTC_HDR = in->textureCompressionASTC_HDR;
3629
3630             out_header->pNext = (VkBaseOutStructure *)out;
3631             out_header = out_header->pNext;
3632             break;
3633         }
3634
3635         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
3636         {
3637             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
3638             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out;
3639
3640             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3641
3642             out->sType = in->sType;
3643             out->pNext = NULL;
3644             out->cooperativeMatrix = in->cooperativeMatrix;
3645             out->cooperativeMatrixRobustBufferAccess = in->cooperativeMatrixRobustBufferAccess;
3646
3647             out_header->pNext = (VkBaseOutStructure *)out;
3648             out_header = out_header->pNext;
3649             break;
3650         }
3651
3652         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
3653         {
3654             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
3655             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out;
3656
3657             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3658
3659             out->sType = in->sType;
3660             out->pNext = NULL;
3661             out->ycbcrImageArrays = in->ycbcrImageArrays;
3662
3663             out_header->pNext = (VkBaseOutStructure *)out;
3664             out_header = out_header->pNext;
3665             break;
3666         }
3667
3668         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
3669         {
3670             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
3671             VkPhysicalDevicePerformanceQueryFeaturesKHR *out;
3672
3673             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3674
3675             out->sType = in->sType;
3676             out->pNext = NULL;
3677             out->performanceCounterQueryPools = in->performanceCounterQueryPools;
3678             out->performanceCounterMultipleQueryPools = in->performanceCounterMultipleQueryPools;
3679
3680             out_header->pNext = (VkBaseOutStructure *)out;
3681             out_header = out_header->pNext;
3682             break;
3683         }
3684
3685         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
3686         {
3687             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
3688             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out;
3689
3690             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3691
3692             out->sType = in->sType;
3693             out->pNext = NULL;
3694             out->coverageReductionMode = in->coverageReductionMode;
3695
3696             out_header->pNext = (VkBaseOutStructure *)out;
3697             out_header = out_header->pNext;
3698             break;
3699         }
3700
3701         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
3702         {
3703             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
3704             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out;
3705
3706             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3707
3708             out->sType = in->sType;
3709             out->pNext = NULL;
3710             out->shaderIntegerFunctions2 = in->shaderIntegerFunctions2;
3711
3712             out_header->pNext = (VkBaseOutStructure *)out;
3713             out_header = out_header->pNext;
3714             break;
3715         }
3716
3717         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
3718         {
3719             const VkPhysicalDeviceShaderClockFeaturesKHR *in = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
3720             VkPhysicalDeviceShaderClockFeaturesKHR *out;
3721
3722             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3723
3724             out->sType = in->sType;
3725             out->pNext = NULL;
3726             out->shaderSubgroupClock = in->shaderSubgroupClock;
3727             out->shaderDeviceClock = in->shaderDeviceClock;
3728
3729             out_header->pNext = (VkBaseOutStructure *)out;
3730             out_header = out_header->pNext;
3731             break;
3732         }
3733
3734         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
3735         {
3736             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
3737             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out;
3738
3739             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3740
3741             out->sType = in->sType;
3742             out->pNext = NULL;
3743             out->indexTypeUint8 = in->indexTypeUint8;
3744
3745             out_header->pNext = (VkBaseOutStructure *)out;
3746             out_header = out_header->pNext;
3747             break;
3748         }
3749
3750         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
3751         {
3752             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
3753             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out;
3754
3755             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3756
3757             out->sType = in->sType;
3758             out->pNext = NULL;
3759             out->shaderSMBuiltins = in->shaderSMBuiltins;
3760
3761             out_header->pNext = (VkBaseOutStructure *)out;
3762             out_header = out_header->pNext;
3763             break;
3764         }
3765
3766         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
3767         {
3768             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
3769             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out;
3770
3771             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3772
3773             out->sType = in->sType;
3774             out->pNext = NULL;
3775             out->fragmentShaderSampleInterlock = in->fragmentShaderSampleInterlock;
3776             out->fragmentShaderPixelInterlock = in->fragmentShaderPixelInterlock;
3777             out->fragmentShaderShadingRateInterlock = in->fragmentShaderShadingRateInterlock;
3778
3779             out_header->pNext = (VkBaseOutStructure *)out;
3780             out_header = out_header->pNext;
3781             break;
3782         }
3783
3784         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
3785         {
3786             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
3787             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out;
3788
3789             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3790
3791             out->sType = in->sType;
3792             out->pNext = NULL;
3793             out->separateDepthStencilLayouts = in->separateDepthStencilLayouts;
3794
3795             out_header->pNext = (VkBaseOutStructure *)out;
3796             out_header = out_header->pNext;
3797             break;
3798         }
3799
3800         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
3801         {
3802             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
3803             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out;
3804
3805             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3806
3807             out->sType = in->sType;
3808             out->pNext = NULL;
3809             out->pipelineExecutableInfo = in->pipelineExecutableInfo;
3810
3811             out_header->pNext = (VkBaseOutStructure *)out;
3812             out_header = out_header->pNext;
3813             break;
3814         }
3815
3816         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
3817         {
3818             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *in = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *)in_header;
3819             VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *out;
3820
3821             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3822
3823             out->sType = in->sType;
3824             out->pNext = NULL;
3825             out->shaderDemoteToHelperInvocation = in->shaderDemoteToHelperInvocation;
3826
3827             out_header->pNext = (VkBaseOutStructure *)out;
3828             out_header = out_header->pNext;
3829             break;
3830         }
3831
3832         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
3833         {
3834             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
3835             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out;
3836
3837             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3838
3839             out->sType = in->sType;
3840             out->pNext = NULL;
3841             out->texelBufferAlignment = in->texelBufferAlignment;
3842
3843             out_header->pNext = (VkBaseOutStructure *)out;
3844             out_header = out_header->pNext;
3845             break;
3846         }
3847
3848         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
3849         {
3850             const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *in = (const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *)in_header;
3851             VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *out;
3852
3853             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3854
3855             out->sType = in->sType;
3856             out->pNext = NULL;
3857             out->subgroupSizeControl = in->subgroupSizeControl;
3858             out->computeFullSubgroups = in->computeFullSubgroups;
3859
3860             out_header->pNext = (VkBaseOutStructure *)out;
3861             out_header = out_header->pNext;
3862             break;
3863         }
3864
3865         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
3866         {
3867             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
3868             VkPhysicalDeviceLineRasterizationFeaturesEXT *out;
3869
3870             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3871
3872             out->sType = in->sType;
3873             out->pNext = NULL;
3874             out->rectangularLines = in->rectangularLines;
3875             out->bresenhamLines = in->bresenhamLines;
3876             out->smoothLines = in->smoothLines;
3877             out->stippledRectangularLines = in->stippledRectangularLines;
3878             out->stippledBresenhamLines = in->stippledBresenhamLines;
3879             out->stippledSmoothLines = in->stippledSmoothLines;
3880
3881             out_header->pNext = (VkBaseOutStructure *)out;
3882             out_header = out_header->pNext;
3883             break;
3884         }
3885
3886         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
3887         {
3888             const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *in = (const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *)in_header;
3889             VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *out;
3890
3891             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3892
3893             out->sType = in->sType;
3894             out->pNext = NULL;
3895             out->pipelineCreationCacheControl = in->pipelineCreationCacheControl;
3896
3897             out_header->pNext = (VkBaseOutStructure *)out;
3898             out_header = out_header->pNext;
3899             break;
3900         }
3901
3902         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
3903         {
3904             const VkPhysicalDeviceVulkan11Features *in = (const VkPhysicalDeviceVulkan11Features *)in_header;
3905             VkPhysicalDeviceVulkan11Features *out;
3906
3907             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3908
3909             out->sType = in->sType;
3910             out->pNext = NULL;
3911             out->storageBuffer16BitAccess = in->storageBuffer16BitAccess;
3912             out->uniformAndStorageBuffer16BitAccess = in->uniformAndStorageBuffer16BitAccess;
3913             out->storagePushConstant16 = in->storagePushConstant16;
3914             out->storageInputOutput16 = in->storageInputOutput16;
3915             out->multiview = in->multiview;
3916             out->multiviewGeometryShader = in->multiviewGeometryShader;
3917             out->multiviewTessellationShader = in->multiviewTessellationShader;
3918             out->variablePointersStorageBuffer = in->variablePointersStorageBuffer;
3919             out->variablePointers = in->variablePointers;
3920             out->protectedMemory = in->protectedMemory;
3921             out->samplerYcbcrConversion = in->samplerYcbcrConversion;
3922             out->shaderDrawParameters = in->shaderDrawParameters;
3923
3924             out_header->pNext = (VkBaseOutStructure *)out;
3925             out_header = out_header->pNext;
3926             break;
3927         }
3928
3929         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
3930         {
3931             const VkPhysicalDeviceVulkan12Features *in = (const VkPhysicalDeviceVulkan12Features *)in_header;
3932             VkPhysicalDeviceVulkan12Features *out;
3933
3934             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3935
3936             out->sType = in->sType;
3937             out->pNext = NULL;
3938             out->samplerMirrorClampToEdge = in->samplerMirrorClampToEdge;
3939             out->drawIndirectCount = in->drawIndirectCount;
3940             out->storageBuffer8BitAccess = in->storageBuffer8BitAccess;
3941             out->uniformAndStorageBuffer8BitAccess = in->uniformAndStorageBuffer8BitAccess;
3942             out->storagePushConstant8 = in->storagePushConstant8;
3943             out->shaderBufferInt64Atomics = in->shaderBufferInt64Atomics;
3944             out->shaderSharedInt64Atomics = in->shaderSharedInt64Atomics;
3945             out->shaderFloat16 = in->shaderFloat16;
3946             out->shaderInt8 = in->shaderInt8;
3947             out->descriptorIndexing = in->descriptorIndexing;
3948             out->shaderInputAttachmentArrayDynamicIndexing = in->shaderInputAttachmentArrayDynamicIndexing;
3949             out->shaderUniformTexelBufferArrayDynamicIndexing = in->shaderUniformTexelBufferArrayDynamicIndexing;
3950             out->shaderStorageTexelBufferArrayDynamicIndexing = in->shaderStorageTexelBufferArrayDynamicIndexing;
3951             out->shaderUniformBufferArrayNonUniformIndexing = in->shaderUniformBufferArrayNonUniformIndexing;
3952             out->shaderSampledImageArrayNonUniformIndexing = in->shaderSampledImageArrayNonUniformIndexing;
3953             out->shaderStorageBufferArrayNonUniformIndexing = in->shaderStorageBufferArrayNonUniformIndexing;
3954             out->shaderStorageImageArrayNonUniformIndexing = in->shaderStorageImageArrayNonUniformIndexing;
3955             out->shaderInputAttachmentArrayNonUniformIndexing = in->shaderInputAttachmentArrayNonUniformIndexing;
3956             out->shaderUniformTexelBufferArrayNonUniformIndexing = in->shaderUniformTexelBufferArrayNonUniformIndexing;
3957             out->shaderStorageTexelBufferArrayNonUniformIndexing = in->shaderStorageTexelBufferArrayNonUniformIndexing;
3958             out->descriptorBindingUniformBufferUpdateAfterBind = in->descriptorBindingUniformBufferUpdateAfterBind;
3959             out->descriptorBindingSampledImageUpdateAfterBind = in->descriptorBindingSampledImageUpdateAfterBind;
3960             out->descriptorBindingStorageImageUpdateAfterBind = in->descriptorBindingStorageImageUpdateAfterBind;
3961             out->descriptorBindingStorageBufferUpdateAfterBind = in->descriptorBindingStorageBufferUpdateAfterBind;
3962             out->descriptorBindingUniformTexelBufferUpdateAfterBind = in->descriptorBindingUniformTexelBufferUpdateAfterBind;
3963             out->descriptorBindingStorageTexelBufferUpdateAfterBind = in->descriptorBindingStorageTexelBufferUpdateAfterBind;
3964             out->descriptorBindingUpdateUnusedWhilePending = in->descriptorBindingUpdateUnusedWhilePending;
3965             out->descriptorBindingPartiallyBound = in->descriptorBindingPartiallyBound;
3966             out->descriptorBindingVariableDescriptorCount = in->descriptorBindingVariableDescriptorCount;
3967             out->runtimeDescriptorArray = in->runtimeDescriptorArray;
3968             out->samplerFilterMinmax = in->samplerFilterMinmax;
3969             out->scalarBlockLayout = in->scalarBlockLayout;
3970             out->imagelessFramebuffer = in->imagelessFramebuffer;
3971             out->uniformBufferStandardLayout = in->uniformBufferStandardLayout;
3972             out->shaderSubgroupExtendedTypes = in->shaderSubgroupExtendedTypes;
3973             out->separateDepthStencilLayouts = in->separateDepthStencilLayouts;
3974             out->hostQueryReset = in->hostQueryReset;
3975             out->timelineSemaphore = in->timelineSemaphore;
3976             out->bufferDeviceAddress = in->bufferDeviceAddress;
3977             out->bufferDeviceAddressCaptureReplay = in->bufferDeviceAddressCaptureReplay;
3978             out->bufferDeviceAddressMultiDevice = in->bufferDeviceAddressMultiDevice;
3979             out->vulkanMemoryModel = in->vulkanMemoryModel;
3980             out->vulkanMemoryModelDeviceScope = in->vulkanMemoryModelDeviceScope;
3981             out->vulkanMemoryModelAvailabilityVisibilityChains = in->vulkanMemoryModelAvailabilityVisibilityChains;
3982             out->shaderOutputViewportIndex = in->shaderOutputViewportIndex;
3983             out->shaderOutputLayer = in->shaderOutputLayer;
3984             out->subgroupBroadcastDynamicId = in->subgroupBroadcastDynamicId;
3985
3986             out_header->pNext = (VkBaseOutStructure *)out;
3987             out_header = out_header->pNext;
3988             break;
3989         }
3990
3991         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
3992         {
3993             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
3994             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out;
3995
3996             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
3997
3998             out->sType = in->sType;
3999             out->pNext = NULL;
4000             out->deviceCoherentMemory = in->deviceCoherentMemory;
4001
4002             out_header->pNext = (VkBaseOutStructure *)out;
4003             out_header = out_header->pNext;
4004             break;
4005         }
4006
4007         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
4008         {
4009             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
4010             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out;
4011
4012             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4013
4014             out->sType = in->sType;
4015             out->pNext = NULL;
4016             out->customBorderColors = in->customBorderColors;
4017             out->customBorderColorWithoutFormat = in->customBorderColorWithoutFormat;
4018
4019             out_header->pNext = (VkBaseOutStructure *)out;
4020             out_header = out_header->pNext;
4021             break;
4022         }
4023
4024         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
4025         {
4026             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
4027             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out;
4028
4029             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4030
4031             out->sType = in->sType;
4032             out->pNext = NULL;
4033             out->extendedDynamicState = in->extendedDynamicState;
4034
4035             out_header->pNext = (VkBaseOutStructure *)out;
4036             out_header = out_header->pNext;
4037             break;
4038         }
4039
4040         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
4041         {
4042             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
4043             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out;
4044
4045             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4046
4047             out->sType = in->sType;
4048             out->pNext = NULL;
4049             out->extendedDynamicState2 = in->extendedDynamicState2;
4050             out->extendedDynamicState2LogicOp = in->extendedDynamicState2LogicOp;
4051             out->extendedDynamicState2PatchControlPoints = in->extendedDynamicState2PatchControlPoints;
4052
4053             out_header->pNext = (VkBaseOutStructure *)out;
4054             out_header = out_header->pNext;
4055             break;
4056         }
4057
4058         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
4059         {
4060             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
4061             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out;
4062
4063             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4064
4065             out->sType = in->sType;
4066             out->pNext = NULL;
4067             out->diagnosticsConfig = in->diagnosticsConfig;
4068
4069             out_header->pNext = (VkBaseOutStructure *)out;
4070             out_header = out_header->pNext;
4071             break;
4072         }
4073
4074         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
4075         {
4076             const VkDeviceDiagnosticsConfigCreateInfoNV *in = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
4077             VkDeviceDiagnosticsConfigCreateInfoNV *out;
4078
4079             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4080
4081             out->sType = in->sType;
4082             out->pNext = NULL;
4083             out->flags = in->flags;
4084
4085             out_header->pNext = (VkBaseOutStructure *)out;
4086             out_header = out_header->pNext;
4087             break;
4088         }
4089
4090         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
4091         {
4092             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *in = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *)in_header;
4093             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *out;
4094
4095             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4096
4097             out->sType = in->sType;
4098             out->pNext = NULL;
4099             out->shaderZeroInitializeWorkgroupMemory = in->shaderZeroInitializeWorkgroupMemory;
4100
4101             out_header->pNext = (VkBaseOutStructure *)out;
4102             out_header = out_header->pNext;
4103             break;
4104         }
4105
4106         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
4107         {
4108             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
4109             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out;
4110
4111             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4112
4113             out->sType = in->sType;
4114             out->pNext = NULL;
4115             out->shaderSubgroupUniformControlFlow = in->shaderSubgroupUniformControlFlow;
4116
4117             out_header->pNext = (VkBaseOutStructure *)out;
4118             out_header = out_header->pNext;
4119             break;
4120         }
4121
4122         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
4123         {
4124             const VkPhysicalDeviceRobustness2FeaturesEXT *in = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
4125             VkPhysicalDeviceRobustness2FeaturesEXT *out;
4126
4127             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4128
4129             out->sType = in->sType;
4130             out->pNext = NULL;
4131             out->robustBufferAccess2 = in->robustBufferAccess2;
4132             out->robustImageAccess2 = in->robustImageAccess2;
4133             out->nullDescriptor = in->nullDescriptor;
4134
4135             out_header->pNext = (VkBaseOutStructure *)out;
4136             out_header = out_header->pNext;
4137             break;
4138         }
4139
4140         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
4141         {
4142             const VkPhysicalDeviceImageRobustnessFeaturesEXT *in = (const VkPhysicalDeviceImageRobustnessFeaturesEXT *)in_header;
4143             VkPhysicalDeviceImageRobustnessFeaturesEXT *out;
4144
4145             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4146
4147             out->sType = in->sType;
4148             out->pNext = NULL;
4149             out->robustImageAccess = in->robustImageAccess;
4150
4151             out_header->pNext = (VkBaseOutStructure *)out;
4152             out_header = out_header->pNext;
4153             break;
4154         }
4155
4156         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
4157         {
4158             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
4159             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out;
4160
4161             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4162
4163             out->sType = in->sType;
4164             out->pNext = NULL;
4165             out->workgroupMemoryExplicitLayout = in->workgroupMemoryExplicitLayout;
4166             out->workgroupMemoryExplicitLayoutScalarBlockLayout = in->workgroupMemoryExplicitLayoutScalarBlockLayout;
4167             out->workgroupMemoryExplicitLayout8BitAccess = in->workgroupMemoryExplicitLayout8BitAccess;
4168             out->workgroupMemoryExplicitLayout16BitAccess = in->workgroupMemoryExplicitLayout16BitAccess;
4169
4170             out_header->pNext = (VkBaseOutStructure *)out;
4171             out_header = out_header->pNext;
4172             break;
4173         }
4174
4175         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
4176         {
4177             const VkPhysicalDevice4444FormatsFeaturesEXT *in = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
4178             VkPhysicalDevice4444FormatsFeaturesEXT *out;
4179
4180             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4181
4182             out->sType = in->sType;
4183             out->pNext = NULL;
4184             out->formatA4R4G4B4 = in->formatA4R4G4B4;
4185             out->formatA4B4G4R4 = in->formatA4B4G4R4;
4186
4187             out_header->pNext = (VkBaseOutStructure *)out;
4188             out_header = out_header->pNext;
4189             break;
4190         }
4191
4192         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
4193         {
4194             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
4195             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out;
4196
4197             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4198
4199             out->sType = in->sType;
4200             out->pNext = NULL;
4201             out->subpassShading = in->subpassShading;
4202
4203             out_header->pNext = (VkBaseOutStructure *)out;
4204             out_header = out_header->pNext;
4205             break;
4206         }
4207
4208         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
4209         {
4210             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
4211             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out;
4212
4213             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4214
4215             out->sType = in->sType;
4216             out->pNext = NULL;
4217             out->shaderImageInt64Atomics = in->shaderImageInt64Atomics;
4218             out->sparseImageInt64Atomics = in->sparseImageInt64Atomics;
4219
4220             out_header->pNext = (VkBaseOutStructure *)out;
4221             out_header = out_header->pNext;
4222             break;
4223         }
4224
4225         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
4226         {
4227             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
4228             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out;
4229
4230             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4231
4232             out->sType = in->sType;
4233             out->pNext = NULL;
4234             out->pipelineFragmentShadingRate = in->pipelineFragmentShadingRate;
4235             out->primitiveFragmentShadingRate = in->primitiveFragmentShadingRate;
4236             out->attachmentFragmentShadingRate = in->attachmentFragmentShadingRate;
4237
4238             out_header->pNext = (VkBaseOutStructure *)out;
4239             out_header = out_header->pNext;
4240             break;
4241         }
4242
4243         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
4244         {
4245             const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *in = (const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *)in_header;
4246             VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *out;
4247
4248             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4249
4250             out->sType = in->sType;
4251             out->pNext = NULL;
4252             out->shaderTerminateInvocation = in->shaderTerminateInvocation;
4253
4254             out_header->pNext = (VkBaseOutStructure *)out;
4255             out_header = out_header->pNext;
4256             break;
4257         }
4258
4259         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
4260         {
4261             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
4262             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out;
4263
4264             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4265
4266             out->sType = in->sType;
4267             out->pNext = NULL;
4268             out->fragmentShadingRateEnums = in->fragmentShadingRateEnums;
4269             out->supersampleFragmentShadingRates = in->supersampleFragmentShadingRates;
4270             out->noInvocationFragmentShadingRates = in->noInvocationFragmentShadingRates;
4271
4272             out_header->pNext = (VkBaseOutStructure *)out;
4273             out_header = out_header->pNext;
4274             break;
4275         }
4276
4277         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
4278         {
4279             const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *in = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *)in_header;
4280             VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *out;
4281
4282             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4283
4284             out->sType = in->sType;
4285             out->pNext = NULL;
4286             out->mutableDescriptorType = in->mutableDescriptorType;
4287
4288             out_header->pNext = (VkBaseOutStructure *)out;
4289             out_header = out_header->pNext;
4290             break;
4291         }
4292
4293         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
4294         {
4295             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
4296             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out;
4297
4298             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4299
4300             out->sType = in->sType;
4301             out->pNext = NULL;
4302             out->vertexInputDynamicState = in->vertexInputDynamicState;
4303
4304             out_header->pNext = (VkBaseOutStructure *)out;
4305             out_header = out_header->pNext;
4306             break;
4307         }
4308
4309         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
4310         {
4311             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
4312             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out;
4313
4314             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4315
4316             out->sType = in->sType;
4317             out->pNext = NULL;
4318             out->colorWriteEnable = in->colorWriteEnable;
4319
4320             out_header->pNext = (VkBaseOutStructure *)out;
4321             out_header = out_header->pNext;
4322             break;
4323         }
4324
4325         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
4326         {
4327             const VkPhysicalDeviceSynchronization2FeaturesKHR *in = (const VkPhysicalDeviceSynchronization2FeaturesKHR *)in_header;
4328             VkPhysicalDeviceSynchronization2FeaturesKHR *out;
4329
4330             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4331
4332             out->sType = in->sType;
4333             out->pNext = NULL;
4334             out->synchronization2 = in->synchronization2;
4335
4336             out_header->pNext = (VkBaseOutStructure *)out;
4337             out_header = out_header->pNext;
4338             break;
4339         }
4340
4341         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
4342         {
4343             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
4344             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out;
4345
4346             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4347
4348             out->sType = in->sType;
4349             out->pNext = NULL;
4350             out->inheritedViewportScissor2D = in->inheritedViewportScissor2D;
4351
4352             out_header->pNext = (VkBaseOutStructure *)out;
4353             out_header = out_header->pNext;
4354             break;
4355         }
4356
4357         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
4358         {
4359             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
4360             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out;
4361
4362             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4363
4364             out->sType = in->sType;
4365             out->pNext = NULL;
4366             out->ycbcr2plane444Formats = in->ycbcr2plane444Formats;
4367
4368             out_header->pNext = (VkBaseOutStructure *)out;
4369             out_header = out_header->pNext;
4370             break;
4371         }
4372
4373         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
4374         {
4375             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
4376             VkPhysicalDeviceProvokingVertexFeaturesEXT *out;
4377
4378             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4379
4380             out->sType = in->sType;
4381             out->pNext = NULL;
4382             out->provokingVertexLast = in->provokingVertexLast;
4383             out->transformFeedbackPreservesProvokingVertex = in->transformFeedbackPreservesProvokingVertex;
4384
4385             out_header->pNext = (VkBaseOutStructure *)out;
4386             out_header = out_header->pNext;
4387             break;
4388         }
4389
4390         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
4391         {
4392             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
4393             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out;
4394
4395             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4396
4397             out->sType = in->sType;
4398             out->pNext = NULL;
4399             out->rayTracingMotionBlur = in->rayTracingMotionBlur;
4400             out->rayTracingMotionBlurPipelineTraceRaysIndirect = in->rayTracingMotionBlurPipelineTraceRaysIndirect;
4401
4402             out_header->pNext = (VkBaseOutStructure *)out;
4403             out_header = out_header->pNext;
4404             break;
4405         }
4406
4407         default:
4408             FIXME("Application requested a linked structure of type %u.\n", in_header->sType);
4409         }
4410     }
4411
4412     return VK_SUCCESS;
4413
4414 out_of_memory:
4415     free_VkDeviceCreateInfo_struct_chain(out_struct);
4416     return VK_ERROR_OUT_OF_HOST_MEMORY;
4417 }
4418
4419 void free_VkDeviceCreateInfo_struct_chain(VkDeviceCreateInfo *s)
4420 {
4421     VkBaseOutStructure *header = (void *)s->pNext;
4422
4423     while (header)
4424     {
4425         void *prev = header;
4426
4427         switch (header->sType)
4428         {
4429             case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
4430             {
4431                 VkDeviceGroupDeviceCreateInfo *structure = (VkDeviceGroupDeviceCreateInfo *) header;
4432                 free_VkPhysicalDevice_array((VkPhysicalDevice *)structure->pPhysicalDevices, structure->physicalDeviceCount);
4433                 break;
4434             }
4435             default:
4436                 break;
4437         }
4438         header = header->pNext;
4439         free(prev);
4440     }
4441
4442     s->pNext = NULL;
4443 }
4444
4445 VkResult convert_VkInstanceCreateInfo_struct_chain(const void *pNext, VkInstanceCreateInfo *out_struct)
4446 {
4447     VkBaseOutStructure *out_header = (VkBaseOutStructure *)out_struct;
4448     const VkBaseInStructure *in_header;
4449
4450     out_header->pNext = NULL;
4451
4452     for (in_header = pNext; in_header; in_header = in_header->pNext)
4453     {
4454         switch (in_header->sType)
4455         {
4456         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
4457             break;
4458
4459         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
4460         {
4461             const VkDebugReportCallbackCreateInfoEXT *in = (const VkDebugReportCallbackCreateInfoEXT *)in_header;
4462             VkDebugReportCallbackCreateInfoEXT *out;
4463
4464             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4465
4466             out->sType = in->sType;
4467             out->pNext = NULL;
4468             out->flags = in->flags;
4469             out->pfnCallback = in->pfnCallback;
4470             out->pUserData = in->pUserData;
4471
4472             out_header->pNext = (VkBaseOutStructure *)out;
4473             out_header = out_header->pNext;
4474             break;
4475         }
4476
4477         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
4478         {
4479             const VkValidationFlagsEXT *in = (const VkValidationFlagsEXT *)in_header;
4480             VkValidationFlagsEXT *out;
4481
4482             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4483
4484             out->sType = in->sType;
4485             out->pNext = NULL;
4486             out->disabledValidationCheckCount = in->disabledValidationCheckCount;
4487             out->pDisabledValidationChecks = in->pDisabledValidationChecks;
4488
4489             out_header->pNext = (VkBaseOutStructure *)out;
4490             out_header = out_header->pNext;
4491             break;
4492         }
4493
4494         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
4495         {
4496             const VkValidationFeaturesEXT *in = (const VkValidationFeaturesEXT *)in_header;
4497             VkValidationFeaturesEXT *out;
4498
4499             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4500
4501             out->sType = in->sType;
4502             out->pNext = NULL;
4503             out->enabledValidationFeatureCount = in->enabledValidationFeatureCount;
4504             out->pEnabledValidationFeatures = in->pEnabledValidationFeatures;
4505             out->disabledValidationFeatureCount = in->disabledValidationFeatureCount;
4506             out->pDisabledValidationFeatures = in->pDisabledValidationFeatures;
4507
4508             out_header->pNext = (VkBaseOutStructure *)out;
4509             out_header = out_header->pNext;
4510             break;
4511         }
4512
4513         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
4514         {
4515             const VkDebugUtilsMessengerCreateInfoEXT *in = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
4516             VkDebugUtilsMessengerCreateInfoEXT *out;
4517
4518             if (!(out = malloc(sizeof(*out)))) goto out_of_memory;
4519
4520             out->sType = in->sType;
4521             out->pNext = NULL;
4522             out->flags = in->flags;
4523             out->messageSeverity = in->messageSeverity;
4524             out->messageType = in->messageType;
4525             out->pfnUserCallback = in->pfnUserCallback;
4526             out->pUserData = in->pUserData;
4527
4528             out_header->pNext = (VkBaseOutStructure *)out;
4529             out_header = out_header->pNext;
4530             break;
4531         }
4532
4533         default:
4534             FIXME("Application requested a linked structure of type %u.\n", in_header->sType);
4535         }
4536     }
4537
4538     return VK_SUCCESS;
4539
4540 out_of_memory:
4541     free_VkInstanceCreateInfo_struct_chain(out_struct);
4542     return VK_ERROR_OUT_OF_HOST_MEMORY;
4543 }
4544
4545 void free_VkInstanceCreateInfo_struct_chain(VkInstanceCreateInfo *s)
4546 {
4547     VkBaseOutStructure *header = (void *)s->pNext;
4548
4549     while (header)
4550     {
4551         void *prev = header;
4552
4553         switch (header->sType)
4554         {
4555             default:
4556                 break;
4557         }
4558         header = header->pNext;
4559         free(prev);
4560     }
4561
4562     s->pNext = NULL;
4563 }
4564
4565 static VkResult WINAPI wine_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
4566 {
4567 #if defined(USE_STRUCT_CONVERSION)
4568     VkResult result;
4569     VkAcquireNextImageInfoKHR_host pAcquireInfo_host;
4570     TRACE("%p, %p, %p\n", device, pAcquireInfo, pImageIndex);
4571
4572     convert_VkAcquireNextImageInfoKHR_win_to_host(pAcquireInfo, &pAcquireInfo_host);
4573     result = device->funcs.p_vkAcquireNextImage2KHR(device->device, &pAcquireInfo_host, pImageIndex);
4574
4575     return result;
4576 #else
4577     TRACE("%p, %p, %p\n", device, pAcquireInfo, pImageIndex);
4578     return device->funcs.p_vkAcquireNextImage2KHR(device->device, pAcquireInfo, pImageIndex);
4579 #endif
4580 }
4581
4582 static VkResult WINAPI wine_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
4583 {
4584     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(swapchain), wine_dbgstr_longlong(timeout), wine_dbgstr_longlong(semaphore), wine_dbgstr_longlong(fence), pImageIndex);
4585     return device->funcs.p_vkAcquireNextImageKHR(device->device, swapchain, timeout, semaphore, fence, pImageIndex);
4586 }
4587
4588 static VkResult WINAPI wine_vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
4589 {
4590     TRACE("%p, %p, %p\n", device, pAcquireInfo, pConfiguration);
4591     return device->funcs.p_vkAcquirePerformanceConfigurationINTEL(device->device, pAcquireInfo, pConfiguration);
4592 }
4593
4594 static VkResult WINAPI wine_vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
4595 {
4596 #if defined(USE_STRUCT_CONVERSION)
4597     VkResult result;
4598     VkAcquireProfilingLockInfoKHR_host pInfo_host;
4599     TRACE("%p, %p\n", device, pInfo);
4600
4601     convert_VkAcquireProfilingLockInfoKHR_win_to_host(pInfo, &pInfo_host);
4602     result = device->funcs.p_vkAcquireProfilingLockKHR(device->device, &pInfo_host);
4603
4604     return result;
4605 #else
4606     TRACE("%p, %p\n", device, pInfo);
4607     return device->funcs.p_vkAcquireProfilingLockKHR(device->device, pInfo);
4608 #endif
4609 }
4610
4611 static VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
4612 {
4613 #if defined(USE_STRUCT_CONVERSION)
4614     VkResult result;
4615     VkDescriptorSetAllocateInfo_host pAllocateInfo_host;
4616     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
4617
4618     convert_VkDescriptorSetAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
4619     result = device->funcs.p_vkAllocateDescriptorSets(device->device, &pAllocateInfo_host, pDescriptorSets);
4620
4621     return result;
4622 #else
4623     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
4624     return device->funcs.p_vkAllocateDescriptorSets(device->device, pAllocateInfo, pDescriptorSets);
4625 #endif
4626 }
4627
4628 static VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
4629 {
4630 #if defined(USE_STRUCT_CONVERSION)
4631     VkResult result;
4632     VkMemoryAllocateInfo_host pAllocateInfo_host;
4633     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
4634
4635     convert_VkMemoryAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
4636     result = device->funcs.p_vkAllocateMemory(device->device, &pAllocateInfo_host, NULL, pMemory);
4637
4638     return result;
4639 #else
4640     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
4641     return device->funcs.p_vkAllocateMemory(device->device, pAllocateInfo, NULL, pMemory);
4642 #endif
4643 }
4644
4645 static VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
4646 {
4647 #if defined(USE_STRUCT_CONVERSION)
4648     VkResult result;
4649     VkCommandBufferBeginInfo_host pBeginInfo_host;
4650     TRACE("%p, %p\n", commandBuffer, pBeginInfo);
4651
4652     convert_VkCommandBufferBeginInfo_win_to_host(pBeginInfo, &pBeginInfo_host);
4653     result = commandBuffer->device->funcs.p_vkBeginCommandBuffer(commandBuffer->command_buffer, &pBeginInfo_host);
4654
4655     free_VkCommandBufferBeginInfo(&pBeginInfo_host);
4656     return result;
4657 #else
4658     TRACE("%p, %p\n", commandBuffer, pBeginInfo);
4659     return commandBuffer->device->funcs.p_vkBeginCommandBuffer(commandBuffer->command_buffer, pBeginInfo);
4660 #endif
4661 }
4662
4663 static VkResult WINAPI wine_vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
4664 {
4665 #if defined(USE_STRUCT_CONVERSION)
4666     VkResult result;
4667     VkBindAccelerationStructureMemoryInfoNV_host *pBindInfos_host;
4668     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4669
4670     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win_to_host(pBindInfos, bindInfoCount);
4671     result = device->funcs.p_vkBindAccelerationStructureMemoryNV(device->device, bindInfoCount, pBindInfos_host);
4672
4673     free_VkBindAccelerationStructureMemoryInfoNV_array(pBindInfos_host, bindInfoCount);
4674     return result;
4675 #else
4676     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4677     return device->funcs.p_vkBindAccelerationStructureMemoryNV(device->device, bindInfoCount, pBindInfos);
4678 #endif
4679 }
4680
4681 static VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
4682 {
4683     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
4684     return device->funcs.p_vkBindBufferMemory(device->device, buffer, memory, memoryOffset);
4685 }
4686
4687 static VkResult WINAPI wine_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
4688 {
4689 #if defined(USE_STRUCT_CONVERSION)
4690     VkResult result;
4691     VkBindBufferMemoryInfo_host *pBindInfos_host;
4692     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4693
4694     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
4695     result = device->funcs.p_vkBindBufferMemory2(device->device, bindInfoCount, pBindInfos_host);
4696
4697     free_VkBindBufferMemoryInfo_array(pBindInfos_host, bindInfoCount);
4698     return result;
4699 #else
4700     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4701     return device->funcs.p_vkBindBufferMemory2(device->device, bindInfoCount, pBindInfos);
4702 #endif
4703 }
4704
4705 static VkResult WINAPI wine_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
4706 {
4707 #if defined(USE_STRUCT_CONVERSION)
4708     VkResult result;
4709     VkBindBufferMemoryInfo_host *pBindInfos_host;
4710     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4711
4712     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
4713     result = device->funcs.p_vkBindBufferMemory2KHR(device->device, bindInfoCount, pBindInfos_host);
4714
4715     free_VkBindBufferMemoryInfo_array(pBindInfos_host, bindInfoCount);
4716     return result;
4717 #else
4718     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4719     return device->funcs.p_vkBindBufferMemory2KHR(device->device, bindInfoCount, pBindInfos);
4720 #endif
4721 }
4722
4723 static VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
4724 {
4725     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(image), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
4726     return device->funcs.p_vkBindImageMemory(device->device, image, memory, memoryOffset);
4727 }
4728
4729 static VkResult WINAPI wine_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
4730 {
4731 #if defined(USE_STRUCT_CONVERSION)
4732     VkResult result;
4733     VkBindImageMemoryInfo_host *pBindInfos_host;
4734     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4735
4736     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
4737     result = device->funcs.p_vkBindImageMemory2(device->device, bindInfoCount, pBindInfos_host);
4738
4739     free_VkBindImageMemoryInfo_array(pBindInfos_host, bindInfoCount);
4740     return result;
4741 #else
4742     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4743     return device->funcs.p_vkBindImageMemory2(device->device, bindInfoCount, pBindInfos);
4744 #endif
4745 }
4746
4747 static VkResult WINAPI wine_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
4748 {
4749 #if defined(USE_STRUCT_CONVERSION)
4750     VkResult result;
4751     VkBindImageMemoryInfo_host *pBindInfos_host;
4752     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4753
4754     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
4755     result = device->funcs.p_vkBindImageMemory2KHR(device->device, bindInfoCount, pBindInfos_host);
4756
4757     free_VkBindImageMemoryInfo_array(pBindInfos_host, bindInfoCount);
4758     return result;
4759 #else
4760     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
4761     return device->funcs.p_vkBindImageMemory2KHR(device->device, bindInfoCount, pBindInfos);
4762 #endif
4763 }
4764
4765 static VkResult WINAPI wine_vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
4766 {
4767 #if defined(USE_STRUCT_CONVERSION)
4768     VkResult result;
4769     VkAccelerationStructureBuildGeometryInfoKHR_host *pInfos_host;
4770     TRACE("%p, 0x%s, %u, %p, %p\n", device, wine_dbgstr_longlong(deferredOperation), infoCount, pInfos, ppBuildRangeInfos);
4771
4772     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win_to_host(pInfos, infoCount);
4773     result = device->funcs.p_vkBuildAccelerationStructuresKHR(device->device, deferredOperation, infoCount, pInfos_host, ppBuildRangeInfos);
4774
4775     free_VkAccelerationStructureBuildGeometryInfoKHR_array(pInfos_host, infoCount);
4776     return result;
4777 #else
4778     TRACE("%p, 0x%s, %u, %p, %p\n", device, wine_dbgstr_longlong(deferredOperation), infoCount, pInfos, ppBuildRangeInfos);
4779     return device->funcs.p_vkBuildAccelerationStructuresKHR(device->device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
4780 #endif
4781 }
4782
4783 static void WINAPI wine_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
4784 {
4785 #if defined(USE_STRUCT_CONVERSION)
4786     VkConditionalRenderingBeginInfoEXT_host pConditionalRenderingBegin_host;
4787     TRACE("%p, %p\n", commandBuffer, pConditionalRenderingBegin);
4788
4789     convert_VkConditionalRenderingBeginInfoEXT_win_to_host(pConditionalRenderingBegin, &pConditionalRenderingBegin_host);
4790     commandBuffer->device->funcs.p_vkCmdBeginConditionalRenderingEXT(commandBuffer->command_buffer, &pConditionalRenderingBegin_host);
4791
4792 #else
4793     TRACE("%p, %p\n", commandBuffer, pConditionalRenderingBegin);
4794     commandBuffer->device->funcs.p_vkCmdBeginConditionalRenderingEXT(commandBuffer->command_buffer, pConditionalRenderingBegin);
4795 #endif
4796 }
4797
4798 static void WINAPI wine_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
4799 {
4800     TRACE("%p, %p\n", commandBuffer, pLabelInfo);
4801     commandBuffer->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(commandBuffer->command_buffer, pLabelInfo);
4802 }
4803
4804 static void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
4805 {
4806     TRACE("%p, 0x%s, %u, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags);
4807     commandBuffer->device->funcs.p_vkCmdBeginQuery(commandBuffer->command_buffer, queryPool, query, flags);
4808 }
4809
4810 static void WINAPI wine_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
4811 {
4812     TRACE("%p, 0x%s, %u, %#x, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags, index);
4813     commandBuffer->device->funcs.p_vkCmdBeginQueryIndexedEXT(commandBuffer->command_buffer, queryPool, query, flags, index);
4814 }
4815
4816 static void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
4817 {
4818 #if defined(USE_STRUCT_CONVERSION)
4819     VkRenderPassBeginInfo_host pRenderPassBegin_host;
4820     TRACE("%p, %p, %#x\n", commandBuffer, pRenderPassBegin, contents);
4821
4822     convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host);
4823     commandBuffer->device->funcs.p_vkCmdBeginRenderPass(commandBuffer->command_buffer, &pRenderPassBegin_host, contents);
4824
4825 #else
4826     TRACE("%p, %p, %#x\n", commandBuffer, pRenderPassBegin, contents);
4827     commandBuffer->device->funcs.p_vkCmdBeginRenderPass(commandBuffer->command_buffer, pRenderPassBegin, contents);
4828 #endif
4829 }
4830
4831 static void WINAPI wine_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
4832 {
4833 #if defined(USE_STRUCT_CONVERSION)
4834     VkRenderPassBeginInfo_host pRenderPassBegin_host;
4835     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
4836
4837     convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host);
4838     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2(commandBuffer->command_buffer, &pRenderPassBegin_host, pSubpassBeginInfo);
4839
4840 #else
4841     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
4842     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2(commandBuffer->command_buffer, pRenderPassBegin, pSubpassBeginInfo);
4843 #endif
4844 }
4845
4846 static void WINAPI wine_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
4847 {
4848 #if defined(USE_STRUCT_CONVERSION)
4849     VkRenderPassBeginInfo_host pRenderPassBegin_host;
4850     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
4851
4852     convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host);
4853     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2KHR(commandBuffer->command_buffer, &pRenderPassBegin_host, pSubpassBeginInfo);
4854
4855 #else
4856     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
4857     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2KHR(commandBuffer->command_buffer, pRenderPassBegin, pSubpassBeginInfo);
4858 #endif
4859 }
4860
4861 static void WINAPI wine_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
4862 {
4863     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
4864     commandBuffer->device->funcs.p_vkCmdBeginTransformFeedbackEXT(commandBuffer->command_buffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
4865 }
4866
4867 static void WINAPI wine_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
4868 {
4869     TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
4870     commandBuffer->device->funcs.p_vkCmdBindDescriptorSets(commandBuffer->command_buffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
4871 }
4872
4873 static void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
4874 {
4875     TRACE("%p, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), indexType);
4876     commandBuffer->device->funcs.p_vkCmdBindIndexBuffer(commandBuffer->command_buffer, buffer, offset, indexType);
4877 }
4878
4879 static void WINAPI wine_vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
4880 {
4881     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(imageView), imageLayout);
4882     commandBuffer->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(commandBuffer->command_buffer, imageView, imageLayout);
4883 }
4884
4885 static void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
4886 {
4887     TRACE("%p, %#x, 0x%s\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline));
4888     commandBuffer->device->funcs.p_vkCmdBindPipeline(commandBuffer->command_buffer, pipelineBindPoint, pipeline);
4889 }
4890
4891 static void WINAPI wine_vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
4892 {
4893     TRACE("%p, %#x, 0x%s, %u\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline), groupIndex);
4894     commandBuffer->device->funcs.p_vkCmdBindPipelineShaderGroupNV(commandBuffer->command_buffer, pipelineBindPoint, pipeline, groupIndex);
4895 }
4896
4897 static void WINAPI wine_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
4898 {
4899     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(imageView), imageLayout);
4900     commandBuffer->device->funcs.p_vkCmdBindShadingRateImageNV(commandBuffer->command_buffer, imageView, imageLayout);
4901 }
4902
4903 static void WINAPI wine_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
4904 {
4905     TRACE("%p, %u, %u, %p, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
4906     commandBuffer->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
4907 }
4908
4909 static void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
4910 {
4911     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
4912     commandBuffer->device->funcs.p_vkCmdBindVertexBuffers(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets);
4913 }
4914
4915 static void WINAPI wine_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
4916 {
4917     TRACE("%p, %u, %u, %p, %p, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
4918     commandBuffer->device->funcs.p_vkCmdBindVertexBuffers2EXT(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
4919 }
4920
4921 static void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
4922 {
4923     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p, %#x\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions, filter);
4924     commandBuffer->device->funcs.p_vkCmdBlitImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
4925 }
4926
4927 static void WINAPI wine_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo)
4928 {
4929 #if defined(USE_STRUCT_CONVERSION)
4930     VkBlitImageInfo2KHR_host pBlitImageInfo_host;
4931     TRACE("%p, %p\n", commandBuffer, pBlitImageInfo);
4932
4933     convert_VkBlitImageInfo2KHR_win_to_host(pBlitImageInfo, &pBlitImageInfo_host);
4934     commandBuffer->device->funcs.p_vkCmdBlitImage2KHR(commandBuffer->command_buffer, &pBlitImageInfo_host);
4935
4936 #else
4937     TRACE("%p, %p\n", commandBuffer, pBlitImageInfo);
4938     commandBuffer->device->funcs.p_vkCmdBlitImage2KHR(commandBuffer->command_buffer, pBlitImageInfo);
4939 #endif
4940 }
4941
4942 static void WINAPI wine_vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
4943 {
4944 #if defined(USE_STRUCT_CONVERSION)
4945     VkAccelerationStructureInfoNV_host pInfo_host;
4946     TRACE("%p, %p, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", commandBuffer, pInfo, wine_dbgstr_longlong(instanceData), wine_dbgstr_longlong(instanceOffset), update, wine_dbgstr_longlong(dst), wine_dbgstr_longlong(src), wine_dbgstr_longlong(scratch), wine_dbgstr_longlong(scratchOffset));
4947
4948     convert_VkAccelerationStructureInfoNV_win_to_host(pInfo, &pInfo_host);
4949     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructureNV(commandBuffer->command_buffer, &pInfo_host, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
4950
4951     free_VkAccelerationStructureInfoNV(&pInfo_host);
4952 #else
4953     TRACE("%p, %p, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", commandBuffer, pInfo, wine_dbgstr_longlong(instanceData), wine_dbgstr_longlong(instanceOffset), update, wine_dbgstr_longlong(dst), wine_dbgstr_longlong(src), wine_dbgstr_longlong(scratch), wine_dbgstr_longlong(scratchOffset));
4954     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructureNV(commandBuffer->command_buffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
4955 #endif
4956 }
4957
4958 static void WINAPI wine_vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts)
4959 {
4960 #if defined(USE_STRUCT_CONVERSION)
4961     VkAccelerationStructureBuildGeometryInfoKHR_host *pInfos_host;
4962     TRACE("%p, %u, %p, %p, %p, %p\n", commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
4963
4964     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win_to_host(pInfos, infoCount);
4965     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer->command_buffer, infoCount, pInfos_host, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
4966
4967     free_VkAccelerationStructureBuildGeometryInfoKHR_array(pInfos_host, infoCount);
4968 #else
4969     TRACE("%p, %u, %p, %p, %p, %p\n", commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
4970     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer->command_buffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
4971 #endif
4972 }
4973
4974 static void WINAPI wine_vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
4975 {
4976 #if defined(USE_STRUCT_CONVERSION)
4977     VkAccelerationStructureBuildGeometryInfoKHR_host *pInfos_host;
4978     TRACE("%p, %u, %p, %p\n", commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
4979
4980     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win_to_host(pInfos, infoCount);
4981     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(commandBuffer->command_buffer, infoCount, pInfos_host, ppBuildRangeInfos);
4982
4983     free_VkAccelerationStructureBuildGeometryInfoKHR_array(pInfos_host, infoCount);
4984 #else
4985     TRACE("%p, %u, %p, %p\n", commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
4986     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(commandBuffer->command_buffer, infoCount, pInfos, ppBuildRangeInfos);
4987 #endif
4988 }
4989
4990 static void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
4991 {
4992     TRACE("%p, %u, %p, %u, %p\n", commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
4993     commandBuffer->device->funcs.p_vkCmdClearAttachments(commandBuffer->command_buffer, attachmentCount, pAttachments, rectCount, pRects);
4994 }
4995
4996 static void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
4997 {
4998     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pColor, rangeCount, pRanges);
4999     commandBuffer->device->funcs.p_vkCmdClearColorImage(commandBuffer->command_buffer, image, imageLayout, pColor, rangeCount, pRanges);
5000 }
5001
5002 static void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
5003 {
5004     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pDepthStencil, rangeCount, pRanges);
5005     commandBuffer->device->funcs.p_vkCmdClearDepthStencilImage(commandBuffer->command_buffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
5006 }
5007
5008 static void WINAPI wine_vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
5009 {
5010 #if defined(USE_STRUCT_CONVERSION)
5011     VkCopyAccelerationStructureInfoKHR_host pInfo_host;
5012     TRACE("%p, %p\n", commandBuffer, pInfo);
5013
5014     convert_VkCopyAccelerationStructureInfoKHR_win_to_host(pInfo, &pInfo_host);
5015     commandBuffer->device->funcs.p_vkCmdCopyAccelerationStructureKHR(commandBuffer->command_buffer, &pInfo_host);
5016
5017 #else
5018     TRACE("%p, %p\n", commandBuffer, pInfo);
5019     commandBuffer->device->funcs.p_vkCmdCopyAccelerationStructureKHR(commandBuffer->command_buffer, pInfo);
5020 #endif
5021 }
5022
5023 static void WINAPI wine_vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
5024 {
5025     TRACE("%p, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(dst), wine_dbgstr_longlong(src), mode);
5026     commandBuffer->device->funcs.p_vkCmdCopyAccelerationStructureNV(commandBuffer->command_buffer, dst, src, mode);
5027 }
5028
5029 static void WINAPI wine_vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
5030 {
5031 #if defined(USE_STRUCT_CONVERSION)
5032     VkCopyAccelerationStructureToMemoryInfoKHR_host pInfo_host;
5033     TRACE("%p, %p\n", commandBuffer, pInfo);
5034
5035     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win_to_host(pInfo, &pInfo_host);
5036     commandBuffer->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer->command_buffer, &pInfo_host);
5037
5038 #else
5039     TRACE("%p, %p\n", commandBuffer, pInfo);
5040     commandBuffer->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer->command_buffer, pInfo);
5041 #endif
5042 }
5043
5044 static void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
5045 {
5046 #if defined(USE_STRUCT_CONVERSION)
5047     VkBufferCopy_host *pRegions_host;
5048     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
5049
5050     pRegions_host = convert_VkBufferCopy_array_win_to_host(pRegions, regionCount);
5051     commandBuffer->device->funcs.p_vkCmdCopyBuffer(commandBuffer->command_buffer, srcBuffer, dstBuffer, regionCount, pRegions_host);
5052
5053     free_VkBufferCopy_array(pRegions_host, regionCount);
5054 #else
5055     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
5056     commandBuffer->device->funcs.p_vkCmdCopyBuffer(commandBuffer->command_buffer, srcBuffer, dstBuffer, regionCount, pRegions);
5057 #endif
5058 }
5059
5060 static void WINAPI wine_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfo)
5061 {
5062 #if defined(USE_STRUCT_CONVERSION)
5063     VkCopyBufferInfo2KHR_host pCopyBufferInfo_host;
5064     TRACE("%p, %p\n", commandBuffer, pCopyBufferInfo);
5065
5066     convert_VkCopyBufferInfo2KHR_win_to_host(pCopyBufferInfo, &pCopyBufferInfo_host);
5067     commandBuffer->device->funcs.p_vkCmdCopyBuffer2KHR(commandBuffer->command_buffer, &pCopyBufferInfo_host);
5068
5069     free_VkCopyBufferInfo2KHR(&pCopyBufferInfo_host);
5070 #else
5071     TRACE("%p, %p\n", commandBuffer, pCopyBufferInfo);
5072     commandBuffer->device->funcs.p_vkCmdCopyBuffer2KHR(commandBuffer->command_buffer, pCopyBufferInfo);
5073 #endif
5074 }
5075
5076 static void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
5077 {
5078 #if defined(USE_STRUCT_CONVERSION)
5079     VkBufferImageCopy_host *pRegions_host;
5080     TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
5081
5082     pRegions_host = convert_VkBufferImageCopy_array_win_to_host(pRegions, regionCount);
5083     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage(commandBuffer->command_buffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions_host);
5084
5085     free_VkBufferImageCopy_array(pRegions_host, regionCount);
5086 #else
5087     TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
5088     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage(commandBuffer->command_buffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
5089 #endif
5090 }
5091
5092 static void WINAPI wine_vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
5093 {
5094 #if defined(USE_STRUCT_CONVERSION)
5095     VkCopyBufferToImageInfo2KHR_host pCopyBufferToImageInfo_host;
5096     TRACE("%p, %p\n", commandBuffer, pCopyBufferToImageInfo);
5097
5098     convert_VkCopyBufferToImageInfo2KHR_win_to_host(pCopyBufferToImageInfo, &pCopyBufferToImageInfo_host);
5099     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage2KHR(commandBuffer->command_buffer, &pCopyBufferToImageInfo_host);
5100
5101     free_VkCopyBufferToImageInfo2KHR(&pCopyBufferToImageInfo_host);
5102 #else
5103     TRACE("%p, %p\n", commandBuffer, pCopyBufferToImageInfo);
5104     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage2KHR(commandBuffer->command_buffer, pCopyBufferToImageInfo);
5105 #endif
5106 }
5107
5108 static void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
5109 {
5110     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
5111     commandBuffer->device->funcs.p_vkCmdCopyImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
5112 }
5113
5114 static void WINAPI wine_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo)
5115 {
5116 #if defined(USE_STRUCT_CONVERSION)
5117     VkCopyImageInfo2KHR_host pCopyImageInfo_host;
5118     TRACE("%p, %p\n", commandBuffer, pCopyImageInfo);
5119
5120     convert_VkCopyImageInfo2KHR_win_to_host(pCopyImageInfo, &pCopyImageInfo_host);
5121     commandBuffer->device->funcs.p_vkCmdCopyImage2KHR(commandBuffer->command_buffer, &pCopyImageInfo_host);
5122
5123 #else
5124     TRACE("%p, %p\n", commandBuffer, pCopyImageInfo);
5125     commandBuffer->device->funcs.p_vkCmdCopyImage2KHR(commandBuffer->command_buffer, pCopyImageInfo);
5126 #endif
5127 }
5128
5129 static void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
5130 {
5131 #if defined(USE_STRUCT_CONVERSION)
5132     VkBufferImageCopy_host *pRegions_host;
5133     TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
5134
5135     pRegions_host = convert_VkBufferImageCopy_array_win_to_host(pRegions, regionCount);
5136     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer(commandBuffer->command_buffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions_host);
5137
5138     free_VkBufferImageCopy_array(pRegions_host, regionCount);
5139 #else
5140     TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
5141     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer(commandBuffer->command_buffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
5142 #endif
5143 }
5144
5145 static void WINAPI wine_vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
5146 {
5147 #if defined(USE_STRUCT_CONVERSION)
5148     VkCopyImageToBufferInfo2KHR_host pCopyImageToBufferInfo_host;
5149     TRACE("%p, %p\n", commandBuffer, pCopyImageToBufferInfo);
5150
5151     convert_VkCopyImageToBufferInfo2KHR_win_to_host(pCopyImageToBufferInfo, &pCopyImageToBufferInfo_host);
5152     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer2KHR(commandBuffer->command_buffer, &pCopyImageToBufferInfo_host);
5153
5154     free_VkCopyImageToBufferInfo2KHR(&pCopyImageToBufferInfo_host);
5155 #else
5156     TRACE("%p, %p\n", commandBuffer, pCopyImageToBufferInfo);
5157     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer2KHR(commandBuffer->command_buffer, pCopyImageToBufferInfo);
5158 #endif
5159 }
5160
5161 static void WINAPI wine_vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
5162 {
5163 #if defined(USE_STRUCT_CONVERSION)
5164     VkCopyMemoryToAccelerationStructureInfoKHR_host pInfo_host;
5165     TRACE("%p, %p\n", commandBuffer, pInfo);
5166
5167     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win_to_host(pInfo, &pInfo_host);
5168     commandBuffer->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer->command_buffer, &pInfo_host);
5169
5170 #else
5171     TRACE("%p, %p\n", commandBuffer, pInfo);
5172     commandBuffer->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer->command_buffer, pInfo);
5173 #endif
5174 }
5175
5176 static void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
5177 {
5178     TRACE("%p, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(stride), flags);
5179     commandBuffer->device->funcs.p_vkCmdCopyQueryPoolResults(commandBuffer->command_buffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
5180 }
5181
5182 static void WINAPI wine_vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
5183 {
5184 #if defined(USE_STRUCT_CONVERSION)
5185     VkCuLaunchInfoNVX_host pLaunchInfo_host;
5186     TRACE("%p, %p\n", commandBuffer, pLaunchInfo);
5187
5188     convert_VkCuLaunchInfoNVX_win_to_host(pLaunchInfo, &pLaunchInfo_host);
5189     commandBuffer->device->funcs.p_vkCmdCuLaunchKernelNVX(commandBuffer->command_buffer, &pLaunchInfo_host);
5190
5191 #else
5192     TRACE("%p, %p\n", commandBuffer, pLaunchInfo);
5193     commandBuffer->device->funcs.p_vkCmdCuLaunchKernelNVX(commandBuffer->command_buffer, pLaunchInfo);
5194 #endif
5195 }
5196
5197 static void WINAPI wine_vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
5198 {
5199     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
5200     commandBuffer->device->funcs.p_vkCmdDebugMarkerBeginEXT(commandBuffer->command_buffer, pMarkerInfo);
5201 }
5202
5203 static void WINAPI wine_vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
5204 {
5205     TRACE("%p\n", commandBuffer);
5206     commandBuffer->device->funcs.p_vkCmdDebugMarkerEndEXT(commandBuffer->command_buffer);
5207 }
5208
5209 static void WINAPI wine_vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
5210 {
5211     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
5212     commandBuffer->device->funcs.p_vkCmdDebugMarkerInsertEXT(commandBuffer->command_buffer, pMarkerInfo);
5213 }
5214
5215 static void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
5216 {
5217     TRACE("%p, %u, %u, %u\n", commandBuffer, groupCountX, groupCountY, groupCountZ);
5218     commandBuffer->device->funcs.p_vkCmdDispatch(commandBuffer->command_buffer, groupCountX, groupCountY, groupCountZ);
5219 }
5220
5221 static void WINAPI wine_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
5222 {
5223     TRACE("%p, %u, %u, %u, %u, %u, %u\n", commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
5224     commandBuffer->device->funcs.p_vkCmdDispatchBase(commandBuffer->command_buffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
5225 }
5226
5227 static void WINAPI wine_vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
5228 {
5229     TRACE("%p, %u, %u, %u, %u, %u, %u\n", commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
5230     commandBuffer->device->funcs.p_vkCmdDispatchBaseKHR(commandBuffer->command_buffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
5231 }
5232
5233 static void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
5234 {
5235     TRACE("%p, 0x%s, 0x%s\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset));
5236     commandBuffer->device->funcs.p_vkCmdDispatchIndirect(commandBuffer->command_buffer, buffer, offset);
5237 }
5238
5239 static void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
5240 {
5241     TRACE("%p, %u, %u, %u, %u\n", commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
5242     commandBuffer->device->funcs.p_vkCmdDraw(commandBuffer->command_buffer, vertexCount, instanceCount, firstVertex, firstInstance);
5243 }
5244
5245 static void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
5246 {
5247     TRACE("%p, %u, %u, %u, %d, %u\n", commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
5248     commandBuffer->device->funcs.p_vkCmdDrawIndexed(commandBuffer->command_buffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
5249 }
5250
5251 static void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
5252 {
5253     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
5254     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
5255 }
5256
5257 static void WINAPI wine_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
5258 {
5259     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
5260     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCount(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
5261 }
5262
5263 static void WINAPI wine_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
5264 {
5265     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
5266     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
5267 }
5268
5269 static void WINAPI wine_vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
5270 {
5271     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
5272     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
5273 }
5274
5275 static void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
5276 {
5277     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
5278     commandBuffer->device->funcs.p_vkCmdDrawIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
5279 }
5280
5281 static void WINAPI wine_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
5282 {
5283     TRACE("%p, %u, %u, 0x%s, 0x%s, %u, %u\n", commandBuffer, instanceCount, firstInstance, wine_dbgstr_longlong(counterBuffer), wine_dbgstr_longlong(counterBufferOffset), counterOffset, vertexStride);
5284     commandBuffer->device->funcs.p_vkCmdDrawIndirectByteCountEXT(commandBuffer->command_buffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
5285 }
5286
5287 static void WINAPI wine_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
5288 {
5289     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
5290     commandBuffer->device->funcs.p_vkCmdDrawIndirectCount(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
5291 }
5292
5293 static void WINAPI wine_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
5294 {
5295     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
5296     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
5297 }
5298
5299 static void WINAPI wine_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
5300 {
5301     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
5302     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountKHR(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
5303 }
5304
5305 static void WINAPI wine_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
5306 {
5307     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
5308     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
5309 }
5310
5311 static void WINAPI wine_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
5312 {
5313     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
5314     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
5315 }
5316
5317 static void WINAPI wine_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
5318 {
5319     TRACE("%p, %u, %u\n", commandBuffer, taskCount, firstTask);
5320     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksNV(commandBuffer->command_buffer, taskCount, firstTask);
5321 }
5322
5323 static void WINAPI wine_vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
5324 {
5325     TRACE("%p, %u, %p, %u, %u, %u\n", commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
5326     commandBuffer->device->funcs.p_vkCmdDrawMultiEXT(commandBuffer->command_buffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
5327 }
5328
5329 static void WINAPI wine_vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
5330 {
5331     TRACE("%p, %u, %p, %u, %u, %u, %p\n", commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
5332     commandBuffer->device->funcs.p_vkCmdDrawMultiIndexedEXT(commandBuffer->command_buffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
5333 }
5334
5335 static void WINAPI wine_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
5336 {
5337     TRACE("%p\n", commandBuffer);
5338     commandBuffer->device->funcs.p_vkCmdEndConditionalRenderingEXT(commandBuffer->command_buffer);
5339 }
5340
5341 static void WINAPI wine_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
5342 {
5343     TRACE("%p\n", commandBuffer);
5344     commandBuffer->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(commandBuffer->command_buffer);
5345 }
5346
5347 static void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
5348 {
5349     TRACE("%p, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query);
5350     commandBuffer->device->funcs.p_vkCmdEndQuery(commandBuffer->command_buffer, queryPool, query);
5351 }
5352
5353 static void WINAPI wine_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
5354 {
5355     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, index);
5356     commandBuffer->device->funcs.p_vkCmdEndQueryIndexedEXT(commandBuffer->command_buffer, queryPool, query, index);
5357 }
5358
5359 static void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
5360 {
5361     TRACE("%p\n", commandBuffer);
5362     commandBuffer->device->funcs.p_vkCmdEndRenderPass(commandBuffer->command_buffer);
5363 }
5364
5365 static void WINAPI wine_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
5366 {
5367     TRACE("%p, %p\n", commandBuffer, pSubpassEndInfo);
5368     commandBuffer->device->funcs.p_vkCmdEndRenderPass2(commandBuffer->command_buffer, pSubpassEndInfo);
5369 }
5370
5371 static void WINAPI wine_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
5372 {
5373     TRACE("%p, %p\n", commandBuffer, pSubpassEndInfo);
5374     commandBuffer->device->funcs.p_vkCmdEndRenderPass2KHR(commandBuffer->command_buffer, pSubpassEndInfo);
5375 }
5376
5377 static void WINAPI wine_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
5378 {
5379     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
5380     commandBuffer->device->funcs.p_vkCmdEndTransformFeedbackEXT(commandBuffer->command_buffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
5381 }
5382
5383 static void WINAPI wine_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
5384 {
5385     VkCommandBuffer *pCommandBuffers_host;
5386     TRACE("%p, %u, %p\n", commandBuffer, commandBufferCount, pCommandBuffers);
5387
5388     pCommandBuffers_host = convert_VkCommandBuffer_array_win_to_host(pCommandBuffers, commandBufferCount);
5389     commandBuffer->device->funcs.p_vkCmdExecuteCommands(commandBuffer->command_buffer, commandBufferCount, pCommandBuffers_host);
5390
5391     free_VkCommandBuffer_array(pCommandBuffers_host, commandBufferCount);
5392 }
5393
5394 static void WINAPI wine_vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
5395 {
5396 #if defined(USE_STRUCT_CONVERSION)
5397     VkGeneratedCommandsInfoNV_host pGeneratedCommandsInfo_host;
5398     TRACE("%p, %u, %p\n", commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
5399
5400     convert_VkGeneratedCommandsInfoNV_win_to_host(pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
5401     commandBuffer->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(commandBuffer->command_buffer, isPreprocessed, &pGeneratedCommandsInfo_host);
5402
5403     free_VkGeneratedCommandsInfoNV(&pGeneratedCommandsInfo_host);
5404 #else
5405     TRACE("%p, %u, %p\n", commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
5406     commandBuffer->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(commandBuffer->command_buffer, isPreprocessed, pGeneratedCommandsInfo);
5407 #endif
5408 }
5409
5410 static void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
5411 {
5412     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data);
5413     commandBuffer->device->funcs.p_vkCmdFillBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, size, data);
5414 }
5415
5416 static void WINAPI wine_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
5417 {
5418     TRACE("%p, %p\n", commandBuffer, pLabelInfo);
5419     commandBuffer->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(commandBuffer->command_buffer, pLabelInfo);
5420 }
5421
5422 static void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
5423 {
5424     TRACE("%p, %#x\n", commandBuffer, contents);
5425     commandBuffer->device->funcs.p_vkCmdNextSubpass(commandBuffer->command_buffer, contents);
5426 }
5427
5428 static void WINAPI wine_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
5429 {
5430     TRACE("%p, %p, %p\n", commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
5431     commandBuffer->device->funcs.p_vkCmdNextSubpass2(commandBuffer->command_buffer, pSubpassBeginInfo, pSubpassEndInfo);
5432 }
5433
5434 static void WINAPI wine_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
5435 {
5436     TRACE("%p, %p, %p\n", commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
5437     commandBuffer->device->funcs.p_vkCmdNextSubpass2KHR(commandBuffer->command_buffer, pSubpassBeginInfo, pSubpassEndInfo);
5438 }
5439
5440 static void WINAPI wine_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)
5441 {
5442 #if defined(USE_STRUCT_CONVERSION)
5443     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
5444     VkImageMemoryBarrier_host *pImageMemoryBarriers_host;
5445     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
5446
5447     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win_to_host(pBufferMemoryBarriers, bufferMemoryBarrierCount);
5448     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win_to_host(pImageMemoryBarriers, imageMemoryBarrierCount);
5449     commandBuffer->device->funcs.p_vkCmdPipelineBarrier(commandBuffer->command_buffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers_host, imageMemoryBarrierCount, pImageMemoryBarriers_host);
5450
5451     free_VkBufferMemoryBarrier_array(pBufferMemoryBarriers_host, bufferMemoryBarrierCount);
5452     free_VkImageMemoryBarrier_array(pImageMemoryBarriers_host, imageMemoryBarrierCount);
5453 #else
5454     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
5455     commandBuffer->device->funcs.p_vkCmdPipelineBarrier(commandBuffer->command_buffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
5456 #endif
5457 }
5458
5459 static void WINAPI wine_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR *pDependencyInfo)
5460 {
5461 #if defined(USE_STRUCT_CONVERSION)
5462     VkDependencyInfoKHR_host pDependencyInfo_host;
5463     TRACE("%p, %p\n", commandBuffer, pDependencyInfo);
5464
5465     convert_VkDependencyInfoKHR_win_to_host(pDependencyInfo, &pDependencyInfo_host);
5466     commandBuffer->device->funcs.p_vkCmdPipelineBarrier2KHR(commandBuffer->command_buffer, &pDependencyInfo_host);
5467
5468     free_VkDependencyInfoKHR(&pDependencyInfo_host);
5469 #else
5470     TRACE("%p, %p\n", commandBuffer, pDependencyInfo);
5471     commandBuffer->device->funcs.p_vkCmdPipelineBarrier2KHR(commandBuffer->command_buffer, pDependencyInfo);
5472 #endif
5473 }
5474
5475 static void WINAPI wine_vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
5476 {
5477 #if defined(USE_STRUCT_CONVERSION)
5478     VkGeneratedCommandsInfoNV_host pGeneratedCommandsInfo_host;
5479     TRACE("%p, %p\n", commandBuffer, pGeneratedCommandsInfo);
5480
5481     convert_VkGeneratedCommandsInfoNV_win_to_host(pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
5482     commandBuffer->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(commandBuffer->command_buffer, &pGeneratedCommandsInfo_host);
5483
5484     free_VkGeneratedCommandsInfoNV(&pGeneratedCommandsInfo_host);
5485 #else
5486     TRACE("%p, %p\n", commandBuffer, pGeneratedCommandsInfo);
5487     commandBuffer->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(commandBuffer->command_buffer, pGeneratedCommandsInfo);
5488 #endif
5489 }
5490
5491 static void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
5492 {
5493     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", commandBuffer, wine_dbgstr_longlong(layout), stageFlags, offset, size, pValues);
5494     commandBuffer->device->funcs.p_vkCmdPushConstants(commandBuffer->command_buffer, layout, stageFlags, offset, size, pValues);
5495 }
5496
5497 static void WINAPI wine_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
5498 {
5499 #if defined(USE_STRUCT_CONVERSION)
5500     VkWriteDescriptorSet_host *pDescriptorWrites_host;
5501     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), set, descriptorWriteCount, pDescriptorWrites);
5502
5503     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win_to_host(pDescriptorWrites, descriptorWriteCount);
5504     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetKHR(commandBuffer->command_buffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites_host);
5505
5506     free_VkWriteDescriptorSet_array(pDescriptorWrites_host, descriptorWriteCount);
5507 #else
5508     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), set, descriptorWriteCount, pDescriptorWrites);
5509     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetKHR(commandBuffer->command_buffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
5510 #endif
5511 }
5512
5513 static void WINAPI wine_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
5514 {
5515     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(descriptorUpdateTemplate), wine_dbgstr_longlong(layout), set, pData);
5516     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer->command_buffer, descriptorUpdateTemplate, layout, set, pData);
5517 }
5518
5519 static void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
5520 {
5521     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
5522     commandBuffer->device->funcs.p_vkCmdResetEvent(commandBuffer->command_buffer, event, stageMask);
5523 }
5524
5525 static void WINAPI wine_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask)
5526 {
5527     TRACE("%p, 0x%s, 0x%s\n", commandBuffer, wine_dbgstr_longlong(event), wine_dbgstr_longlong(stageMask));
5528     commandBuffer->device->funcs.p_vkCmdResetEvent2KHR(commandBuffer->command_buffer, event, stageMask);
5529 }
5530
5531 static void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
5532 {
5533     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
5534     commandBuffer->device->funcs.p_vkCmdResetQueryPool(commandBuffer->command_buffer, queryPool, firstQuery, queryCount);
5535 }
5536
5537 static void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
5538 {
5539     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
5540     commandBuffer->device->funcs.p_vkCmdResolveImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
5541 }
5542
5543 static void WINAPI wine_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo)
5544 {
5545 #if defined(USE_STRUCT_CONVERSION)
5546     VkResolveImageInfo2KHR_host pResolveImageInfo_host;
5547     TRACE("%p, %p\n", commandBuffer, pResolveImageInfo);
5548
5549     convert_VkResolveImageInfo2KHR_win_to_host(pResolveImageInfo, &pResolveImageInfo_host);
5550     commandBuffer->device->funcs.p_vkCmdResolveImage2KHR(commandBuffer->command_buffer, &pResolveImageInfo_host);
5551
5552 #else
5553     TRACE("%p, %p\n", commandBuffer, pResolveImageInfo);
5554     commandBuffer->device->funcs.p_vkCmdResolveImage2KHR(commandBuffer->command_buffer, pResolveImageInfo);
5555 #endif
5556 }
5557
5558 static void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
5559 {
5560     TRACE("%p, %p\n", commandBuffer, blendConstants);
5561     commandBuffer->device->funcs.p_vkCmdSetBlendConstants(commandBuffer->command_buffer, blendConstants);
5562 }
5563
5564 static void WINAPI wine_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
5565 {
5566     TRACE("%p, %p\n", commandBuffer, pCheckpointMarker);
5567     commandBuffer->device->funcs.p_vkCmdSetCheckpointNV(commandBuffer->command_buffer, pCheckpointMarker);
5568 }
5569
5570 static void WINAPI wine_vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
5571 {
5572     TRACE("%p, %#x, %u, %p\n", commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
5573     commandBuffer->device->funcs.p_vkCmdSetCoarseSampleOrderNV(commandBuffer->command_buffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
5574 }
5575
5576 static void WINAPI wine_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
5577 {
5578     TRACE("%p, %u, %p\n", commandBuffer, attachmentCount, pColorWriteEnables);
5579     commandBuffer->device->funcs.p_vkCmdSetColorWriteEnableEXT(commandBuffer->command_buffer, attachmentCount, pColorWriteEnables);
5580 }
5581
5582 static void WINAPI wine_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
5583 {
5584     TRACE("%p, %#x\n", commandBuffer, cullMode);
5585     commandBuffer->device->funcs.p_vkCmdSetCullModeEXT(commandBuffer->command_buffer, cullMode);
5586 }
5587
5588 static void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
5589 {
5590     TRACE("%p, %f, %f, %f\n", commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
5591     commandBuffer->device->funcs.p_vkCmdSetDepthBias(commandBuffer->command_buffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
5592 }
5593
5594 static void WINAPI wine_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
5595 {
5596     TRACE("%p, %u\n", commandBuffer, depthBiasEnable);
5597     commandBuffer->device->funcs.p_vkCmdSetDepthBiasEnableEXT(commandBuffer->command_buffer, depthBiasEnable);
5598 }
5599
5600 static void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
5601 {
5602     TRACE("%p, %f, %f\n", commandBuffer, minDepthBounds, maxDepthBounds);
5603     commandBuffer->device->funcs.p_vkCmdSetDepthBounds(commandBuffer->command_buffer, minDepthBounds, maxDepthBounds);
5604 }
5605
5606 static void WINAPI wine_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
5607 {
5608     TRACE("%p, %u\n", commandBuffer, depthBoundsTestEnable);
5609     commandBuffer->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(commandBuffer->command_buffer, depthBoundsTestEnable);
5610 }
5611
5612 static void WINAPI wine_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
5613 {
5614     TRACE("%p, %#x\n", commandBuffer, depthCompareOp);
5615     commandBuffer->device->funcs.p_vkCmdSetDepthCompareOpEXT(commandBuffer->command_buffer, depthCompareOp);
5616 }
5617
5618 static void WINAPI wine_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
5619 {
5620     TRACE("%p, %u\n", commandBuffer, depthTestEnable);
5621     commandBuffer->device->funcs.p_vkCmdSetDepthTestEnableEXT(commandBuffer->command_buffer, depthTestEnable);
5622 }
5623
5624 static void WINAPI wine_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
5625 {
5626     TRACE("%p, %u\n", commandBuffer, depthWriteEnable);
5627     commandBuffer->device->funcs.p_vkCmdSetDepthWriteEnableEXT(commandBuffer->command_buffer, depthWriteEnable);
5628 }
5629
5630 static void WINAPI wine_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
5631 {
5632     TRACE("%p, %u\n", commandBuffer, deviceMask);
5633     commandBuffer->device->funcs.p_vkCmdSetDeviceMask(commandBuffer->command_buffer, deviceMask);
5634 }
5635
5636 static void WINAPI wine_vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
5637 {
5638     TRACE("%p, %u\n", commandBuffer, deviceMask);
5639     commandBuffer->device->funcs.p_vkCmdSetDeviceMaskKHR(commandBuffer->command_buffer, deviceMask);
5640 }
5641
5642 static void WINAPI wine_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
5643 {
5644     TRACE("%p, %u, %u, %p\n", commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
5645     commandBuffer->device->funcs.p_vkCmdSetDiscardRectangleEXT(commandBuffer->command_buffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
5646 }
5647
5648 static void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
5649 {
5650     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
5651     commandBuffer->device->funcs.p_vkCmdSetEvent(commandBuffer->command_buffer, event, stageMask);
5652 }
5653
5654 static void WINAPI wine_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR *pDependencyInfo)
5655 {
5656 #if defined(USE_STRUCT_CONVERSION)
5657     VkDependencyInfoKHR_host pDependencyInfo_host;
5658     TRACE("%p, 0x%s, %p\n", commandBuffer, wine_dbgstr_longlong(event), pDependencyInfo);
5659
5660     convert_VkDependencyInfoKHR_win_to_host(pDependencyInfo, &pDependencyInfo_host);
5661     commandBuffer->device->funcs.p_vkCmdSetEvent2KHR(commandBuffer->command_buffer, event, &pDependencyInfo_host);
5662
5663     free_VkDependencyInfoKHR(&pDependencyInfo_host);
5664 #else
5665     TRACE("%p, 0x%s, %p\n", commandBuffer, wine_dbgstr_longlong(event), pDependencyInfo);
5666     commandBuffer->device->funcs.p_vkCmdSetEvent2KHR(commandBuffer->command_buffer, event, pDependencyInfo);
5667 #endif
5668 }
5669
5670 static void WINAPI wine_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
5671 {
5672     TRACE("%p, %u, %u, %p\n", commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
5673     commandBuffer->device->funcs.p_vkCmdSetExclusiveScissorNV(commandBuffer->command_buffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
5674 }
5675
5676 static void WINAPI wine_vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
5677 {
5678     TRACE("%p, %#x, %p\n", commandBuffer, shadingRate, combinerOps);
5679     commandBuffer->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(commandBuffer->command_buffer, shadingRate, combinerOps);
5680 }
5681
5682 static void WINAPI wine_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
5683 {
5684     TRACE("%p, %p, %p\n", commandBuffer, pFragmentSize, combinerOps);
5685     commandBuffer->device->funcs.p_vkCmdSetFragmentShadingRateKHR(commandBuffer->command_buffer, pFragmentSize, combinerOps);
5686 }
5687
5688 static void WINAPI wine_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
5689 {
5690     TRACE("%p, %#x\n", commandBuffer, frontFace);
5691     commandBuffer->device->funcs.p_vkCmdSetFrontFaceEXT(commandBuffer->command_buffer, frontFace);
5692 }
5693
5694 static void WINAPI wine_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
5695 {
5696     TRACE("%p, %u, %u\n", commandBuffer, lineStippleFactor, lineStipplePattern);
5697     commandBuffer->device->funcs.p_vkCmdSetLineStippleEXT(commandBuffer->command_buffer, lineStippleFactor, lineStipplePattern);
5698 }
5699
5700 static void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
5701 {
5702     TRACE("%p, %f\n", commandBuffer, lineWidth);
5703     commandBuffer->device->funcs.p_vkCmdSetLineWidth(commandBuffer->command_buffer, lineWidth);
5704 }
5705
5706 static void WINAPI wine_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
5707 {
5708     TRACE("%p, %#x\n", commandBuffer, logicOp);
5709     commandBuffer->device->funcs.p_vkCmdSetLogicOpEXT(commandBuffer->command_buffer, logicOp);
5710 }
5711
5712 static void WINAPI wine_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
5713 {
5714     TRACE("%p, %u\n", commandBuffer, patchControlPoints);
5715     commandBuffer->device->funcs.p_vkCmdSetPatchControlPointsEXT(commandBuffer->command_buffer, patchControlPoints);
5716 }
5717
5718 static VkResult WINAPI wine_vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
5719 {
5720 #if defined(USE_STRUCT_CONVERSION)
5721     VkResult result;
5722     VkPerformanceMarkerInfoINTEL_host pMarkerInfo_host;
5723     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
5724
5725     convert_VkPerformanceMarkerInfoINTEL_win_to_host(pMarkerInfo, &pMarkerInfo_host);
5726     result = commandBuffer->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(commandBuffer->command_buffer, &pMarkerInfo_host);
5727
5728     return result;
5729 #else
5730     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
5731     return commandBuffer->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(commandBuffer->command_buffer, pMarkerInfo);
5732 #endif
5733 }
5734
5735 static VkResult WINAPI wine_vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
5736 {
5737 #if defined(USE_STRUCT_CONVERSION)
5738     VkResult result;
5739     VkPerformanceOverrideInfoINTEL_host pOverrideInfo_host;
5740     TRACE("%p, %p\n", commandBuffer, pOverrideInfo);
5741
5742     convert_VkPerformanceOverrideInfoINTEL_win_to_host(pOverrideInfo, &pOverrideInfo_host);
5743     result = commandBuffer->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(commandBuffer->command_buffer, &pOverrideInfo_host);
5744
5745     return result;
5746 #else
5747     TRACE("%p, %p\n", commandBuffer, pOverrideInfo);
5748     return commandBuffer->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(commandBuffer->command_buffer, pOverrideInfo);
5749 #endif
5750 }
5751
5752 static VkResult WINAPI wine_vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
5753 {
5754     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
5755     return commandBuffer->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer->command_buffer, pMarkerInfo);
5756 }
5757
5758 static void WINAPI wine_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
5759 {
5760     TRACE("%p, %u\n", commandBuffer, primitiveRestartEnable);
5761     commandBuffer->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(commandBuffer->command_buffer, primitiveRestartEnable);
5762 }
5763
5764 static void WINAPI wine_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
5765 {
5766     TRACE("%p, %#x\n", commandBuffer, primitiveTopology);
5767     commandBuffer->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(commandBuffer->command_buffer, primitiveTopology);
5768 }
5769
5770 static void WINAPI wine_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
5771 {
5772     TRACE("%p, %u\n", commandBuffer, rasterizerDiscardEnable);
5773     commandBuffer->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(commandBuffer->command_buffer, rasterizerDiscardEnable);
5774 }
5775
5776 static void WINAPI wine_vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
5777 {
5778     TRACE("%p, %u\n", commandBuffer, pipelineStackSize);
5779     commandBuffer->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer->command_buffer, pipelineStackSize);
5780 }
5781
5782 static void WINAPI wine_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
5783 {
5784     TRACE("%p, %p\n", commandBuffer, pSampleLocationsInfo);
5785     commandBuffer->device->funcs.p_vkCmdSetSampleLocationsEXT(commandBuffer->command_buffer, pSampleLocationsInfo);
5786 }
5787
5788 static void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
5789 {
5790     TRACE("%p, %u, %u, %p\n", commandBuffer, firstScissor, scissorCount, pScissors);
5791     commandBuffer->device->funcs.p_vkCmdSetScissor(commandBuffer->command_buffer, firstScissor, scissorCount, pScissors);
5792 }
5793
5794 static void WINAPI wine_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
5795 {
5796     TRACE("%p, %u, %p\n", commandBuffer, scissorCount, pScissors);
5797     commandBuffer->device->funcs.p_vkCmdSetScissorWithCountEXT(commandBuffer->command_buffer, scissorCount, pScissors);
5798 }
5799
5800 static void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
5801 {
5802     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, compareMask);
5803     commandBuffer->device->funcs.p_vkCmdSetStencilCompareMask(commandBuffer->command_buffer, faceMask, compareMask);
5804 }
5805
5806 static void WINAPI wine_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
5807 {
5808     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
5809     commandBuffer->device->funcs.p_vkCmdSetStencilOpEXT(commandBuffer->command_buffer, faceMask, failOp, passOp, depthFailOp, compareOp);
5810 }
5811
5812 static void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
5813 {
5814     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, reference);
5815     commandBuffer->device->funcs.p_vkCmdSetStencilReference(commandBuffer->command_buffer, faceMask, reference);
5816 }
5817
5818 static void WINAPI wine_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
5819 {
5820     TRACE("%p, %u\n", commandBuffer, stencilTestEnable);
5821     commandBuffer->device->funcs.p_vkCmdSetStencilTestEnableEXT(commandBuffer->command_buffer, stencilTestEnable);
5822 }
5823
5824 static void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
5825 {
5826     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, writeMask);
5827     commandBuffer->device->funcs.p_vkCmdSetStencilWriteMask(commandBuffer->command_buffer, faceMask, writeMask);
5828 }
5829
5830 static void WINAPI wine_vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
5831 {
5832     TRACE("%p, %u, %p, %u, %p\n", commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
5833     commandBuffer->device->funcs.p_vkCmdSetVertexInputEXT(commandBuffer->command_buffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
5834 }
5835
5836 static void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
5837 {
5838     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewports);
5839     commandBuffer->device->funcs.p_vkCmdSetViewport(commandBuffer->command_buffer, firstViewport, viewportCount, pViewports);
5840 }
5841
5842 static void WINAPI wine_vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
5843 {
5844     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
5845     commandBuffer->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(commandBuffer->command_buffer, firstViewport, viewportCount, pShadingRatePalettes);
5846 }
5847
5848 static void WINAPI wine_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
5849 {
5850     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewportWScalings);
5851     commandBuffer->device->funcs.p_vkCmdSetViewportWScalingNV(commandBuffer->command_buffer, firstViewport, viewportCount, pViewportWScalings);
5852 }
5853
5854 static void WINAPI wine_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
5855 {
5856     TRACE("%p, %u, %p\n", commandBuffer, viewportCount, pViewports);
5857     commandBuffer->device->funcs.p_vkCmdSetViewportWithCountEXT(commandBuffer->command_buffer, viewportCount, pViewports);
5858 }
5859
5860 static void WINAPI wine_vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer)
5861 {
5862     TRACE("%p\n", commandBuffer);
5863     commandBuffer->device->funcs.p_vkCmdSubpassShadingHUAWEI(commandBuffer->command_buffer);
5864 }
5865
5866 static void WINAPI wine_vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
5867 {
5868 #if defined(USE_STRUCT_CONVERSION)
5869     VkStridedDeviceAddressRegionKHR_host pRaygenShaderBindingTable_host;
5870     VkStridedDeviceAddressRegionKHR_host pMissShaderBindingTable_host;
5871     VkStridedDeviceAddressRegionKHR_host pHitShaderBindingTable_host;
5872     VkStridedDeviceAddressRegionKHR_host pCallableShaderBindingTable_host;
5873     TRACE("%p, %p, %p, %p, %p, 0x%s\n", commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, wine_dbgstr_longlong(indirectDeviceAddress));
5874
5875     convert_VkStridedDeviceAddressRegionKHR_win_to_host(pRaygenShaderBindingTable, &pRaygenShaderBindingTable_host);
5876     convert_VkStridedDeviceAddressRegionKHR_win_to_host(pMissShaderBindingTable, &pMissShaderBindingTable_host);
5877     convert_VkStridedDeviceAddressRegionKHR_win_to_host(pHitShaderBindingTable, &pHitShaderBindingTable_host);
5878     convert_VkStridedDeviceAddressRegionKHR_win_to_host(pCallableShaderBindingTable, &pCallableShaderBindingTable_host);
5879     commandBuffer->device->funcs.p_vkCmdTraceRaysIndirectKHR(commandBuffer->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, indirectDeviceAddress);
5880
5881 #else
5882     TRACE("%p, %p, %p, %p, %p, 0x%s\n", commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, wine_dbgstr_longlong(indirectDeviceAddress));
5883     commandBuffer->device->funcs.p_vkCmdTraceRaysIndirectKHR(commandBuffer->command_buffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
5884 #endif
5885 }
5886
5887 static void WINAPI wine_vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
5888 {
5889 #if defined(USE_STRUCT_CONVERSION)
5890     VkStridedDeviceAddressRegionKHR_host pRaygenShaderBindingTable_host;
5891     VkStridedDeviceAddressRegionKHR_host pMissShaderBindingTable_host;
5892     VkStridedDeviceAddressRegionKHR_host pHitShaderBindingTable_host;
5893     VkStridedDeviceAddressRegionKHR_host pCallableShaderBindingTable_host;
5894     TRACE("%p, %p, %p, %p, %p, %u, %u, %u\n", commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
5895
5896     convert_VkStridedDeviceAddressRegionKHR_win_to_host(pRaygenShaderBindingTable, &pRaygenShaderBindingTable_host);
5897     convert_VkStridedDeviceAddressRegionKHR_win_to_host(pMissShaderBindingTable, &pMissShaderBindingTable_host);
5898     convert_VkStridedDeviceAddressRegionKHR_win_to_host(pHitShaderBindingTable, &pHitShaderBindingTable_host);
5899     convert_VkStridedDeviceAddressRegionKHR_win_to_host(pCallableShaderBindingTable, &pCallableShaderBindingTable_host);
5900     commandBuffer->device->funcs.p_vkCmdTraceRaysKHR(commandBuffer->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, width, height, depth);
5901
5902 #else
5903     TRACE("%p, %p, %p, %p, %p, %u, %u, %u\n", commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
5904     commandBuffer->device->funcs.p_vkCmdTraceRaysKHR(commandBuffer->command_buffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
5905 #endif
5906 }
5907
5908 static void WINAPI wine_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)
5909 {
5910     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u, %u\n", commandBuffer, wine_dbgstr_longlong(raygenShaderBindingTableBuffer), wine_dbgstr_longlong(raygenShaderBindingOffset), wine_dbgstr_longlong(missShaderBindingTableBuffer), wine_dbgstr_longlong(missShaderBindingOffset), wine_dbgstr_longlong(missShaderBindingStride), wine_dbgstr_longlong(hitShaderBindingTableBuffer), wine_dbgstr_longlong(hitShaderBindingOffset), wine_dbgstr_longlong(hitShaderBindingStride), wine_dbgstr_longlong(callableShaderBindingTableBuffer), wine_dbgstr_longlong(callableShaderBindingOffset), wine_dbgstr_longlong(callableShaderBindingStride), width, height, depth);
5911     commandBuffer->device->funcs.p_vkCmdTraceRaysNV(commandBuffer->command_buffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
5912 }
5913
5914 static void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
5915 {
5916     TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(dataSize), pData);
5917     commandBuffer->device->funcs.p_vkCmdUpdateBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, dataSize, pData);
5918 }
5919
5920 static void WINAPI wine_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)
5921 {
5922 #if defined(USE_STRUCT_CONVERSION)
5923     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
5924     VkImageMemoryBarrier_host *pImageMemoryBarriers_host;
5925     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
5926
5927     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win_to_host(pBufferMemoryBarriers, bufferMemoryBarrierCount);
5928     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win_to_host(pImageMemoryBarriers, imageMemoryBarrierCount);
5929     commandBuffer->device->funcs.p_vkCmdWaitEvents(commandBuffer->command_buffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers_host, imageMemoryBarrierCount, pImageMemoryBarriers_host);
5930
5931     free_VkBufferMemoryBarrier_array(pBufferMemoryBarriers_host, bufferMemoryBarrierCount);
5932     free_VkImageMemoryBarrier_array(pImageMemoryBarriers_host, imageMemoryBarrierCount);
5933 #else
5934     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
5935     commandBuffer->device->funcs.p_vkCmdWaitEvents(commandBuffer->command_buffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
5936 #endif
5937 }
5938
5939 static void WINAPI wine_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfoKHR *pDependencyInfos)
5940 {
5941 #if defined(USE_STRUCT_CONVERSION)
5942     VkDependencyInfoKHR_host *pDependencyInfos_host;
5943     TRACE("%p, %u, %p, %p\n", commandBuffer, eventCount, pEvents, pDependencyInfos);
5944
5945     pDependencyInfos_host = convert_VkDependencyInfoKHR_array_win_to_host(pDependencyInfos, eventCount);
5946     commandBuffer->device->funcs.p_vkCmdWaitEvents2KHR(commandBuffer->command_buffer, eventCount, pEvents, pDependencyInfos_host);
5947
5948     free_VkDependencyInfoKHR_array(pDependencyInfos_host, eventCount);
5949 #else
5950     TRACE("%p, %u, %p, %p\n", commandBuffer, eventCount, pEvents, pDependencyInfos);
5951     commandBuffer->device->funcs.p_vkCmdWaitEvents2KHR(commandBuffer->command_buffer, eventCount, pEvents, pDependencyInfos);
5952 #endif
5953 }
5954
5955 static void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
5956 {
5957     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, wine_dbgstr_longlong(queryPool), firstQuery);
5958     commandBuffer->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer->command_buffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
5959 }
5960
5961 static void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
5962 {
5963     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, wine_dbgstr_longlong(queryPool), firstQuery);
5964     commandBuffer->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer->command_buffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
5965 }
5966
5967 static void WINAPI wine_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
5968 {
5969     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(stage), wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), marker);
5970     commandBuffer->device->funcs.p_vkCmdWriteBufferMarker2AMD(commandBuffer->command_buffer, stage, dstBuffer, dstOffset, marker);
5971 }
5972
5973 static void WINAPI wine_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
5974 {
5975     TRACE("%p, %#x, 0x%s, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), marker);
5976     commandBuffer->device->funcs.p_vkCmdWriteBufferMarkerAMD(commandBuffer->command_buffer, pipelineStage, dstBuffer, dstOffset, marker);
5977 }
5978
5979 static void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
5980 {
5981     TRACE("%p, %#x, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(queryPool), query);
5982     commandBuffer->device->funcs.p_vkCmdWriteTimestamp(commandBuffer->command_buffer, pipelineStage, queryPool, query);
5983 }
5984
5985 static void WINAPI wine_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query)
5986 {
5987     TRACE("%p, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(stage), wine_dbgstr_longlong(queryPool), query);
5988     commandBuffer->device->funcs.p_vkCmdWriteTimestamp2KHR(commandBuffer->command_buffer, stage, queryPool, query);
5989 }
5990
5991 static VkResult WINAPI wine_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
5992 {
5993     TRACE("%p, 0x%s, %u\n", device, wine_dbgstr_longlong(pipeline), shader);
5994     return device->funcs.p_vkCompileDeferredNV(device->device, pipeline, shader);
5995 }
5996
5997 static VkResult WINAPI wine_vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
5998 {
5999 #if defined(USE_STRUCT_CONVERSION)
6000     VkResult result;
6001     VkCopyAccelerationStructureInfoKHR_host pInfo_host;
6002     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(deferredOperation), pInfo);
6003
6004     convert_VkCopyAccelerationStructureInfoKHR_win_to_host(pInfo, &pInfo_host);
6005     result = device->funcs.p_vkCopyAccelerationStructureKHR(device->device, deferredOperation, &pInfo_host);
6006
6007     return result;
6008 #else
6009     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(deferredOperation), pInfo);
6010     return device->funcs.p_vkCopyAccelerationStructureKHR(device->device, deferredOperation, pInfo);
6011 #endif
6012 }
6013
6014 static VkResult WINAPI wine_vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
6015 {
6016 #if defined(USE_STRUCT_CONVERSION)
6017     VkResult result;
6018     VkCopyAccelerationStructureToMemoryInfoKHR_host pInfo_host;
6019     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(deferredOperation), pInfo);
6020
6021     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win_to_host(pInfo, &pInfo_host);
6022     result = device->funcs.p_vkCopyAccelerationStructureToMemoryKHR(device->device, deferredOperation, &pInfo_host);
6023
6024     return result;
6025 #else
6026     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(deferredOperation), pInfo);
6027     return device->funcs.p_vkCopyAccelerationStructureToMemoryKHR(device->device, deferredOperation, pInfo);
6028 #endif
6029 }
6030
6031 static VkResult WINAPI wine_vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
6032 {
6033 #if defined(USE_STRUCT_CONVERSION)
6034     VkResult result;
6035     VkCopyMemoryToAccelerationStructureInfoKHR_host pInfo_host;
6036     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(deferredOperation), pInfo);
6037
6038     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win_to_host(pInfo, &pInfo_host);
6039     result = device->funcs.p_vkCopyMemoryToAccelerationStructureKHR(device->device, deferredOperation, &pInfo_host);
6040
6041     return result;
6042 #else
6043     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(deferredOperation), pInfo);
6044     return device->funcs.p_vkCopyMemoryToAccelerationStructureKHR(device->device, deferredOperation, pInfo);
6045 #endif
6046 }
6047
6048 static VkResult WINAPI wine_vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
6049 {
6050 #if defined(USE_STRUCT_CONVERSION)
6051     VkResult result;
6052     VkAccelerationStructureCreateInfoKHR_host pCreateInfo_host;
6053     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pAccelerationStructure);
6054
6055     convert_VkAccelerationStructureCreateInfoKHR_win_to_host(pCreateInfo, &pCreateInfo_host);
6056     result = device->funcs.p_vkCreateAccelerationStructureKHR(device->device, &pCreateInfo_host, NULL, pAccelerationStructure);
6057
6058     return result;
6059 #else
6060     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pAccelerationStructure);
6061     return device->funcs.p_vkCreateAccelerationStructureKHR(device->device, pCreateInfo, NULL, pAccelerationStructure);
6062 #endif
6063 }
6064
6065 static VkResult WINAPI wine_vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
6066 {
6067 #if defined(USE_STRUCT_CONVERSION)
6068     VkResult result;
6069     VkAccelerationStructureCreateInfoNV_host pCreateInfo_host;
6070     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pAccelerationStructure);
6071
6072     convert_VkAccelerationStructureCreateInfoNV_win_to_host(pCreateInfo, &pCreateInfo_host);
6073     result = device->funcs.p_vkCreateAccelerationStructureNV(device->device, &pCreateInfo_host, NULL, pAccelerationStructure);
6074
6075     return result;
6076 #else
6077     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pAccelerationStructure);
6078     return device->funcs.p_vkCreateAccelerationStructureNV(device->device, pCreateInfo, NULL, pAccelerationStructure);
6079 #endif
6080 }
6081
6082 static VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
6083 {
6084 #if defined(USE_STRUCT_CONVERSION)
6085     VkResult result;
6086     VkBufferCreateInfo_host pCreateInfo_host;
6087     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
6088
6089     convert_VkBufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
6090     result = device->funcs.p_vkCreateBuffer(device->device, &pCreateInfo_host, NULL, pBuffer);
6091
6092     return result;
6093 #else
6094     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
6095     return device->funcs.p_vkCreateBuffer(device->device, pCreateInfo, NULL, pBuffer);
6096 #endif
6097 }
6098
6099 static VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
6100 {
6101 #if defined(USE_STRUCT_CONVERSION)
6102     VkResult result;
6103     VkBufferViewCreateInfo_host pCreateInfo_host;
6104     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
6105
6106     convert_VkBufferViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
6107     result = device->funcs.p_vkCreateBufferView(device->device, &pCreateInfo_host, NULL, pView);
6108
6109     return result;
6110 #else
6111     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
6112     return device->funcs.p_vkCreateBufferView(device->device, pCreateInfo, NULL, pView);
6113 #endif
6114 }
6115
6116 static VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
6117 {
6118 #if defined(USE_STRUCT_CONVERSION)
6119     VkResult result;
6120     VkComputePipelineCreateInfo_host *pCreateInfos_host;
6121     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
6122
6123     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
6124     result = device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
6125
6126     free_VkComputePipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
6127     return result;
6128 #else
6129     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
6130     return device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
6131 #endif
6132 }
6133
6134 static VkResult WINAPI wine_vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
6135 {
6136 #if defined(USE_STRUCT_CONVERSION)
6137     VkResult result;
6138     VkCuFunctionCreateInfoNVX_host pCreateInfo_host;
6139     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFunction);
6140
6141     convert_VkCuFunctionCreateInfoNVX_win_to_host(pCreateInfo, &pCreateInfo_host);
6142     result = device->funcs.p_vkCreateCuFunctionNVX(device->device, &pCreateInfo_host, NULL, pFunction);
6143
6144     return result;
6145 #else
6146     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFunction);
6147     return device->funcs.p_vkCreateCuFunctionNVX(device->device, pCreateInfo, NULL, pFunction);
6148 #endif
6149 }
6150
6151 static VkResult WINAPI wine_vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
6152 {
6153     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pModule);
6154     return device->funcs.p_vkCreateCuModuleNVX(device->device, pCreateInfo, NULL, pModule);
6155 }
6156
6157 static VkResult WINAPI wine_vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
6158 {
6159     TRACE("%p, %p, %p\n", device, pAllocator, pDeferredOperation);
6160     return device->funcs.p_vkCreateDeferredOperationKHR(device->device, NULL, pDeferredOperation);
6161 }
6162
6163 static VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
6164 {
6165     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorPool);
6166     return device->funcs.p_vkCreateDescriptorPool(device->device, pCreateInfo, NULL, pDescriptorPool);
6167 }
6168
6169 static VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
6170 {
6171     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSetLayout);
6172     return device->funcs.p_vkCreateDescriptorSetLayout(device->device, pCreateInfo, NULL, pSetLayout);
6173 }
6174
6175 static VkResult WINAPI wine_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
6176 {
6177 #if defined(USE_STRUCT_CONVERSION)
6178     VkResult result;
6179     VkDescriptorUpdateTemplateCreateInfo_host pCreateInfo_host;
6180     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
6181
6182     convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
6183     result = device->funcs.p_vkCreateDescriptorUpdateTemplate(device->device, &pCreateInfo_host, NULL, pDescriptorUpdateTemplate);
6184
6185     return result;
6186 #else
6187     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
6188     return device->funcs.p_vkCreateDescriptorUpdateTemplate(device->device, pCreateInfo, NULL, pDescriptorUpdateTemplate);
6189 #endif
6190 }
6191
6192 static VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
6193 {
6194 #if defined(USE_STRUCT_CONVERSION)
6195     VkResult result;
6196     VkDescriptorUpdateTemplateCreateInfo_host pCreateInfo_host;
6197     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
6198
6199     convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
6200     result = device->funcs.p_vkCreateDescriptorUpdateTemplateKHR(device->device, &pCreateInfo_host, NULL, pDescriptorUpdateTemplate);
6201
6202     return result;
6203 #else
6204     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
6205     return device->funcs.p_vkCreateDescriptorUpdateTemplateKHR(device->device, pCreateInfo, NULL, pDescriptorUpdateTemplate);
6206 #endif
6207 }
6208
6209 static VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
6210 {
6211     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pEvent);
6212     return device->funcs.p_vkCreateEvent(device->device, pCreateInfo, NULL, pEvent);
6213 }
6214
6215 static VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
6216 {
6217     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFence);
6218     return device->funcs.p_vkCreateFence(device->device, pCreateInfo, NULL, pFence);
6219 }
6220
6221 static VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
6222 {
6223 #if defined(USE_STRUCT_CONVERSION)
6224     VkResult result;
6225     VkFramebufferCreateInfo_host pCreateInfo_host;
6226     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
6227
6228     convert_VkFramebufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
6229     result = device->funcs.p_vkCreateFramebuffer(device->device, &pCreateInfo_host, NULL, pFramebuffer);
6230
6231     return result;
6232 #else
6233     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
6234     return device->funcs.p_vkCreateFramebuffer(device->device, pCreateInfo, NULL, pFramebuffer);
6235 #endif
6236 }
6237
6238 static VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
6239 {
6240 #if defined(USE_STRUCT_CONVERSION)
6241     VkResult result;
6242     VkGraphicsPipelineCreateInfo_host *pCreateInfos_host;
6243     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
6244
6245     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
6246     result = device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
6247
6248     free_VkGraphicsPipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
6249     return result;
6250 #else
6251     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
6252     return device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
6253 #endif
6254 }
6255
6256 static VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
6257 {
6258     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pImage);
6259     return device->funcs.p_vkCreateImage(device->device, pCreateInfo, NULL, pImage);
6260 }
6261
6262 static VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
6263 {
6264 #if defined(USE_STRUCT_CONVERSION)
6265     VkResult result;
6266     VkImageViewCreateInfo_host pCreateInfo_host;
6267     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
6268
6269     convert_VkImageViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
6270     result = device->funcs.p_vkCreateImageView(device->device, &pCreateInfo_host, NULL, pView);
6271
6272     return result;
6273 #else
6274     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
6275     return device->funcs.p_vkCreateImageView(device->device, pCreateInfo, NULL, pView);
6276 #endif
6277 }
6278
6279 static VkResult WINAPI wine_vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
6280 {
6281 #if defined(USE_STRUCT_CONVERSION)
6282     VkResult result;
6283     VkIndirectCommandsLayoutCreateInfoNV_host pCreateInfo_host;
6284     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
6285
6286     convert_VkIndirectCommandsLayoutCreateInfoNV_win_to_host(pCreateInfo, &pCreateInfo_host);
6287     result = device->funcs.p_vkCreateIndirectCommandsLayoutNV(device->device, &pCreateInfo_host, NULL, pIndirectCommandsLayout);
6288
6289     free_VkIndirectCommandsLayoutCreateInfoNV(&pCreateInfo_host);
6290     return result;
6291 #else
6292     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
6293     return device->funcs.p_vkCreateIndirectCommandsLayoutNV(device->device, pCreateInfo, NULL, pIndirectCommandsLayout);
6294 #endif
6295 }
6296
6297 static VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
6298 {
6299     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineCache);
6300     return device->funcs.p_vkCreatePipelineCache(device->device, pCreateInfo, NULL, pPipelineCache);
6301 }
6302
6303 static VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
6304 {
6305     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineLayout);
6306     return device->funcs.p_vkCreatePipelineLayout(device->device, pCreateInfo, NULL, pPipelineLayout);
6307 }
6308
6309 static VkResult WINAPI wine_vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlotEXT *pPrivateDataSlot)
6310 {
6311     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPrivateDataSlot);
6312     return device->funcs.p_vkCreatePrivateDataSlotEXT(device->device, pCreateInfo, NULL, pPrivateDataSlot);
6313 }
6314
6315 static VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
6316 {
6317     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pQueryPool);
6318     return device->funcs.p_vkCreateQueryPool(device->device, pCreateInfo, NULL, pQueryPool);
6319 }
6320
6321 static VkResult WINAPI wine_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
6322 {
6323 #if defined(USE_STRUCT_CONVERSION)
6324     VkResult result;
6325     VkRayTracingPipelineCreateInfoKHR_host *pCreateInfos_host;
6326     TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(deferredOperation), wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
6327
6328     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win_to_host(pCreateInfos, createInfoCount);
6329     result = device->funcs.p_vkCreateRayTracingPipelinesKHR(device->device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
6330
6331     free_VkRayTracingPipelineCreateInfoKHR_array(pCreateInfos_host, createInfoCount);
6332     return result;
6333 #else
6334     TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(deferredOperation), wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
6335     return device->funcs.p_vkCreateRayTracingPipelinesKHR(device->device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
6336 #endif
6337 }
6338
6339 static VkResult WINAPI wine_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
6340 {
6341 #if defined(USE_STRUCT_CONVERSION)
6342     VkResult result;
6343     VkRayTracingPipelineCreateInfoNV_host *pCreateInfos_host;
6344     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
6345
6346     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win_to_host(pCreateInfos, createInfoCount);
6347     result = device->funcs.p_vkCreateRayTracingPipelinesNV(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
6348
6349     free_VkRayTracingPipelineCreateInfoNV_array(pCreateInfos_host, createInfoCount);
6350     return result;
6351 #else
6352     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
6353     return device->funcs.p_vkCreateRayTracingPipelinesNV(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
6354 #endif
6355 }
6356
6357 static VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
6358 {
6359     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
6360     return device->funcs.p_vkCreateRenderPass(device->device, pCreateInfo, NULL, pRenderPass);
6361 }
6362
6363 static VkResult WINAPI wine_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
6364 {
6365     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
6366     return device->funcs.p_vkCreateRenderPass2(device->device, pCreateInfo, NULL, pRenderPass);
6367 }
6368
6369 static VkResult WINAPI wine_vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
6370 {
6371     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
6372     return device->funcs.p_vkCreateRenderPass2KHR(device->device, pCreateInfo, NULL, pRenderPass);
6373 }
6374
6375 static VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
6376 {
6377     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSampler);
6378     return device->funcs.p_vkCreateSampler(device->device, pCreateInfo, NULL, pSampler);
6379 }
6380
6381 static VkResult WINAPI wine_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
6382 {
6383     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion);
6384     return device->funcs.p_vkCreateSamplerYcbcrConversion(device->device, pCreateInfo, NULL, pYcbcrConversion);
6385 }
6386
6387 static VkResult WINAPI wine_vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
6388 {
6389     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion);
6390     return device->funcs.p_vkCreateSamplerYcbcrConversionKHR(device->device, pCreateInfo, NULL, pYcbcrConversion);
6391 }
6392
6393 static VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
6394 {
6395     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSemaphore);
6396     return device->funcs.p_vkCreateSemaphore(device->device, pCreateInfo, NULL, pSemaphore);
6397 }
6398
6399 static VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
6400 {
6401     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pShaderModule);
6402     return device->funcs.p_vkCreateShaderModule(device->device, pCreateInfo, NULL, pShaderModule);
6403 }
6404
6405 static VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
6406 {
6407 #if defined(USE_STRUCT_CONVERSION)
6408     VkResult result;
6409     VkSwapchainCreateInfoKHR_host pCreateInfo_host;
6410     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSwapchain);
6411
6412     convert_VkSwapchainCreateInfoKHR_win_to_host(pCreateInfo, &pCreateInfo_host);
6413     result = device->funcs.p_vkCreateSwapchainKHR(device->device, &pCreateInfo_host, NULL, pSwapchain);
6414
6415     return result;
6416 #else
6417     VkResult result;
6418     VkSwapchainCreateInfoKHR pCreateInfo_host;
6419     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSwapchain);
6420
6421     convert_VkSwapchainCreateInfoKHR_win_to_host(pCreateInfo, &pCreateInfo_host);
6422     result = device->funcs.p_vkCreateSwapchainKHR(device->device, &pCreateInfo_host, NULL, pSwapchain);
6423
6424     return result;
6425 #endif
6426 }
6427
6428 static VkResult WINAPI wine_vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
6429 {
6430     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pValidationCache);
6431     return device->funcs.p_vkCreateValidationCacheEXT(device->device, pCreateInfo, NULL, pValidationCache);
6432 }
6433
6434 static VkResult WINAPI wine_vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
6435 {
6436 #if defined(USE_STRUCT_CONVERSION)
6437     VkResult result;
6438     VkDebugMarkerObjectNameInfoEXT_host pNameInfo_host;
6439     TRACE("%p, %p\n", device, pNameInfo);
6440
6441     convert_VkDebugMarkerObjectNameInfoEXT_win_to_host(pNameInfo, &pNameInfo_host);
6442     result = device->funcs.p_vkDebugMarkerSetObjectNameEXT(device->device, &pNameInfo_host);
6443
6444     return result;
6445 #else
6446     VkResult result;
6447     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
6448     TRACE("%p, %p\n", device, pNameInfo);
6449
6450     convert_VkDebugMarkerObjectNameInfoEXT_win_to_host(pNameInfo, &pNameInfo_host);
6451     result = device->funcs.p_vkDebugMarkerSetObjectNameEXT(device->device, &pNameInfo_host);
6452
6453     return result;
6454 #endif
6455 }
6456
6457 static VkResult WINAPI wine_vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
6458 {
6459 #if defined(USE_STRUCT_CONVERSION)
6460     VkResult result;
6461     VkDebugMarkerObjectTagInfoEXT_host pTagInfo_host;
6462     TRACE("%p, %p\n", device, pTagInfo);
6463
6464     convert_VkDebugMarkerObjectTagInfoEXT_win_to_host(pTagInfo, &pTagInfo_host);
6465     result = device->funcs.p_vkDebugMarkerSetObjectTagEXT(device->device, &pTagInfo_host);
6466
6467     return result;
6468 #else
6469     VkResult result;
6470     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
6471     TRACE("%p, %p\n", device, pTagInfo);
6472
6473     convert_VkDebugMarkerObjectTagInfoEXT_win_to_host(pTagInfo, &pTagInfo_host);
6474     result = device->funcs.p_vkDebugMarkerSetObjectTagEXT(device->device, &pTagInfo_host);
6475
6476     return result;
6477 #endif
6478 }
6479
6480 static void WINAPI wine_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
6481 {
6482     TRACE("%p, %#x, %#x, 0x%s, 0x%s, %d, %p, %p\n", instance, flags, objectType, wine_dbgstr_longlong(object), wine_dbgstr_longlong(location), messageCode, pLayerPrefix, pMessage);
6483     instance->funcs.p_vkDebugReportMessageEXT(instance->instance, flags, objectType, wine_vk_unwrap_handle(objectType, object), location, messageCode, pLayerPrefix, pMessage);
6484 }
6485
6486 static VkResult WINAPI wine_vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
6487 {
6488     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(operation));
6489     return device->funcs.p_vkDeferredOperationJoinKHR(device->device, operation);
6490 }
6491
6492 static void WINAPI wine_vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
6493 {
6494     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), pAllocator);
6495     device->funcs.p_vkDestroyAccelerationStructureKHR(device->device, accelerationStructure, NULL);
6496 }
6497
6498 static void WINAPI wine_vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
6499 {
6500     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), pAllocator);
6501     device->funcs.p_vkDestroyAccelerationStructureNV(device->device, accelerationStructure, NULL);
6502 }
6503
6504 static void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
6505 {
6506     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pAllocator);
6507     device->funcs.p_vkDestroyBuffer(device->device, buffer, NULL);
6508 }
6509
6510 static void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
6511 {
6512     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(bufferView), pAllocator);
6513     device->funcs.p_vkDestroyBufferView(device->device, bufferView, NULL);
6514 }
6515
6516 static void WINAPI wine_vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
6517 {
6518     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(function), pAllocator);
6519     device->funcs.p_vkDestroyCuFunctionNVX(device->device, function, NULL);
6520 }
6521
6522 static void WINAPI wine_vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
6523 {
6524     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(module), pAllocator);
6525     device->funcs.p_vkDestroyCuModuleNVX(device->device, module, NULL);
6526 }
6527
6528 static void WINAPI wine_vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
6529 {
6530     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(operation), pAllocator);
6531     device->funcs.p_vkDestroyDeferredOperationKHR(device->device, operation, NULL);
6532 }
6533
6534 static void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
6535 {
6536     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorPool), pAllocator);
6537     device->funcs.p_vkDestroyDescriptorPool(device->device, descriptorPool, NULL);
6538 }
6539
6540 static void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
6541 {
6542     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSetLayout), pAllocator);
6543     device->funcs.p_vkDestroyDescriptorSetLayout(device->device, descriptorSetLayout, NULL);
6544 }
6545
6546 static void WINAPI wine_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
6547 {
6548     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator);
6549     device->funcs.p_vkDestroyDescriptorUpdateTemplate(device->device, descriptorUpdateTemplate, NULL);
6550 }
6551
6552 static void WINAPI wine_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
6553 {
6554     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator);
6555     device->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(device->device, descriptorUpdateTemplate, NULL);
6556 }
6557
6558 static void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
6559 {
6560     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(event), pAllocator);
6561     device->funcs.p_vkDestroyEvent(device->device, event, NULL);
6562 }
6563
6564 static void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
6565 {
6566     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(fence), pAllocator);
6567     device->funcs.p_vkDestroyFence(device->device, fence, NULL);
6568 }
6569
6570 static void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
6571 {
6572     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(framebuffer), pAllocator);
6573     device->funcs.p_vkDestroyFramebuffer(device->device, framebuffer, NULL);
6574 }
6575
6576 static void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
6577 {
6578     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pAllocator);
6579     device->funcs.p_vkDestroyImage(device->device, image, NULL);
6580 }
6581
6582 static void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
6583 {
6584     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(imageView), pAllocator);
6585     device->funcs.p_vkDestroyImageView(device->device, imageView, NULL);
6586 }
6587
6588 static void WINAPI wine_vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
6589 {
6590     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(indirectCommandsLayout), pAllocator);
6591     device->funcs.p_vkDestroyIndirectCommandsLayoutNV(device->device, indirectCommandsLayout, NULL);
6592 }
6593
6594 static void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
6595 {
6596     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), pAllocator);
6597     device->funcs.p_vkDestroyPipeline(device->device, pipeline, NULL);
6598 }
6599
6600 static void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
6601 {
6602     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineCache), pAllocator);
6603     device->funcs.p_vkDestroyPipelineCache(device->device, pipelineCache, NULL);
6604 }
6605
6606 static void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
6607 {
6608     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineLayout), pAllocator);
6609     device->funcs.p_vkDestroyPipelineLayout(device->device, pipelineLayout, NULL);
6610 }
6611
6612 static void WINAPI wine_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks *pAllocator)
6613 {
6614     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(privateDataSlot), pAllocator);
6615     device->funcs.p_vkDestroyPrivateDataSlotEXT(device->device, privateDataSlot, NULL);
6616 }
6617
6618 static void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
6619 {
6620     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(queryPool), pAllocator);
6621     device->funcs.p_vkDestroyQueryPool(device->device, queryPool, NULL);
6622 }
6623
6624 static void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
6625 {
6626     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pAllocator);
6627     device->funcs.p_vkDestroyRenderPass(device->device, renderPass, NULL);
6628 }
6629
6630 static void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
6631 {
6632     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(sampler), pAllocator);
6633     device->funcs.p_vkDestroySampler(device->device, sampler, NULL);
6634 }
6635
6636 static void WINAPI wine_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
6637 {
6638     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator);
6639     device->funcs.p_vkDestroySamplerYcbcrConversion(device->device, ycbcrConversion, NULL);
6640 }
6641
6642 static void WINAPI wine_vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
6643 {
6644     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator);
6645     device->funcs.p_vkDestroySamplerYcbcrConversionKHR(device->device, ycbcrConversion, NULL);
6646 }
6647
6648 static void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
6649 {
6650     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pAllocator);
6651     device->funcs.p_vkDestroySemaphore(device->device, semaphore, NULL);
6652 }
6653
6654 static void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
6655 {
6656     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(shaderModule), pAllocator);
6657     device->funcs.p_vkDestroyShaderModule(device->device, shaderModule, NULL);
6658 }
6659
6660 static void WINAPI wine_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
6661 {
6662     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(swapchain), pAllocator);
6663     device->funcs.p_vkDestroySwapchainKHR(device->device, swapchain, NULL);
6664 }
6665
6666 static void WINAPI wine_vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
6667 {
6668     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(validationCache), pAllocator);
6669     device->funcs.p_vkDestroyValidationCacheEXT(device->device, validationCache, NULL);
6670 }
6671
6672 static VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
6673 {
6674     TRACE("%p\n", device);
6675     return device->funcs.p_vkDeviceWaitIdle(device->device);
6676 }
6677
6678 static VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
6679 {
6680     TRACE("%p\n", commandBuffer);
6681     return commandBuffer->device->funcs.p_vkEndCommandBuffer(commandBuffer->command_buffer);
6682 }
6683
6684 static VkResult WINAPI wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
6685 {
6686     TRACE("%p, %u, %p, %p, %p\n", physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
6687     return physicalDevice->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice->phys_dev, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
6688 }
6689
6690 static VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
6691 {
6692 #if defined(USE_STRUCT_CONVERSION)
6693     VkResult result;
6694     VkMappedMemoryRange_host *pMemoryRanges_host;
6695     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
6696
6697     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
6698     result = device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
6699
6700     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
6701     return result;
6702 #else
6703     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
6704     return device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
6705 #endif
6706 }
6707
6708 static VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
6709 {
6710     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(descriptorPool), descriptorSetCount, pDescriptorSets);
6711     return device->funcs.p_vkFreeDescriptorSets(device->device, descriptorPool, descriptorSetCount, pDescriptorSets);
6712 }
6713
6714 static void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
6715 {
6716     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pAllocator);
6717     device->funcs.p_vkFreeMemory(device->device, memory, NULL);
6718 }
6719
6720 static void WINAPI wine_vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
6721 {
6722 #if defined(USE_STRUCT_CONVERSION)
6723     VkAccelerationStructureBuildGeometryInfoKHR_host pBuildInfo_host;
6724     VkAccelerationStructureBuildSizesInfoKHR_host pSizeInfo_host;
6725     TRACE("%p, %#x, %p, %p, %p\n", device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
6726
6727     convert_VkAccelerationStructureBuildGeometryInfoKHR_win_to_host(pBuildInfo, &pBuildInfo_host);
6728     convert_VkAccelerationStructureBuildSizesInfoKHR_win_to_host(pSizeInfo, &pSizeInfo_host);
6729     device->funcs.p_vkGetAccelerationStructureBuildSizesKHR(device->device, buildType, &pBuildInfo_host, pMaxPrimitiveCounts, &pSizeInfo_host);
6730
6731 #else
6732     TRACE("%p, %#x, %p, %p, %p\n", device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
6733     device->funcs.p_vkGetAccelerationStructureBuildSizesKHR(device->device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
6734 #endif
6735 }
6736
6737 static VkDeviceAddress WINAPI wine_vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
6738 {
6739 #if defined(USE_STRUCT_CONVERSION)
6740     VkDeviceAddress result;
6741     VkAccelerationStructureDeviceAddressInfoKHR_host pInfo_host;
6742     TRACE("%p, %p\n", device, pInfo);
6743
6744     convert_VkAccelerationStructureDeviceAddressInfoKHR_win_to_host(pInfo, &pInfo_host);
6745     result = device->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(device->device, &pInfo_host);
6746
6747     return result;
6748 #else
6749     TRACE("%p, %p\n", device, pInfo);
6750     return device->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(device->device, pInfo);
6751 #endif
6752 }
6753
6754 static VkResult WINAPI wine_vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
6755 {
6756     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), wine_dbgstr_longlong(dataSize), pData);
6757     return device->funcs.p_vkGetAccelerationStructureHandleNV(device->device, accelerationStructure, dataSize, pData);
6758 }
6759
6760 static void WINAPI wine_vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
6761 {
6762 #if defined(USE_STRUCT_CONVERSION)
6763     VkAccelerationStructureMemoryRequirementsInfoNV_host pInfo_host;
6764     VkMemoryRequirements2KHR_host pMemoryRequirements_host;
6765     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
6766
6767     convert_VkAccelerationStructureMemoryRequirementsInfoNV_win_to_host(pInfo, &pInfo_host);
6768     convert_VkMemoryRequirements2KHR_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
6769     device->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(device->device, &pInfo_host, &pMemoryRequirements_host);
6770
6771     convert_VkMemoryRequirements2KHR_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
6772 #else
6773     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
6774     device->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(device->device, pInfo, pMemoryRequirements);
6775 #endif
6776 }
6777
6778 static VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
6779 {
6780 #if defined(USE_STRUCT_CONVERSION)
6781     VkDeviceAddress result;
6782     VkBufferDeviceAddressInfo_host pInfo_host;
6783     TRACE("%p, %p\n", device, pInfo);
6784
6785     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
6786     result = device->funcs.p_vkGetBufferDeviceAddress(device->device, &pInfo_host);
6787
6788     return result;
6789 #else
6790     TRACE("%p, %p\n", device, pInfo);
6791     return device->funcs.p_vkGetBufferDeviceAddress(device->device, pInfo);
6792 #endif
6793 }
6794
6795 static VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
6796 {
6797 #if defined(USE_STRUCT_CONVERSION)
6798     VkDeviceAddress result;
6799     VkBufferDeviceAddressInfo_host pInfo_host;
6800     TRACE("%p, %p\n", device, pInfo);
6801
6802     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
6803     result = device->funcs.p_vkGetBufferDeviceAddressEXT(device->device, &pInfo_host);
6804
6805     return result;
6806 #else
6807     TRACE("%p, %p\n", device, pInfo);
6808     return device->funcs.p_vkGetBufferDeviceAddressEXT(device->device, pInfo);
6809 #endif
6810 }
6811
6812 static VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
6813 {
6814 #if defined(USE_STRUCT_CONVERSION)
6815     VkDeviceAddress result;
6816     VkBufferDeviceAddressInfo_host pInfo_host;
6817     TRACE("%p, %p\n", device, pInfo);
6818
6819     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
6820     result = device->funcs.p_vkGetBufferDeviceAddressKHR(device->device, &pInfo_host);
6821
6822     return result;
6823 #else
6824     TRACE("%p, %p\n", device, pInfo);
6825     return device->funcs.p_vkGetBufferDeviceAddressKHR(device->device, pInfo);
6826 #endif
6827 }
6828
6829 static void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
6830 {
6831 #if defined(USE_STRUCT_CONVERSION)
6832     VkMemoryRequirements_host pMemoryRequirements_host;
6833     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
6834
6835     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, &pMemoryRequirements_host);
6836
6837     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
6838 #else
6839     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
6840     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, pMemoryRequirements);
6841 #endif
6842 }
6843
6844 static void WINAPI wine_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
6845 {
6846 #if defined(USE_STRUCT_CONVERSION)
6847     VkBufferMemoryRequirementsInfo2_host pInfo_host;
6848     VkMemoryRequirements2_host pMemoryRequirements_host;
6849     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
6850
6851     convert_VkBufferMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
6852     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
6853     device->funcs.p_vkGetBufferMemoryRequirements2(device->device, &pInfo_host, &pMemoryRequirements_host);
6854
6855     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
6856 #else
6857     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
6858     device->funcs.p_vkGetBufferMemoryRequirements2(device->device, pInfo, pMemoryRequirements);
6859 #endif
6860 }
6861
6862 static void WINAPI wine_vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
6863 {
6864 #if defined(USE_STRUCT_CONVERSION)
6865     VkBufferMemoryRequirementsInfo2_host pInfo_host;
6866     VkMemoryRequirements2_host pMemoryRequirements_host;
6867     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
6868
6869     convert_VkBufferMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
6870     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
6871     device->funcs.p_vkGetBufferMemoryRequirements2KHR(device->device, &pInfo_host, &pMemoryRequirements_host);
6872
6873     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
6874 #else
6875     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
6876     device->funcs.p_vkGetBufferMemoryRequirements2KHR(device->device, pInfo, pMemoryRequirements);
6877 #endif
6878 }
6879
6880 static uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
6881 {
6882 #if defined(USE_STRUCT_CONVERSION)
6883     uint64_t result;
6884     VkBufferDeviceAddressInfo_host pInfo_host;
6885     TRACE("%p, %p\n", device, pInfo);
6886
6887     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
6888     result = device->funcs.p_vkGetBufferOpaqueCaptureAddress(device->device, &pInfo_host);
6889
6890     return result;
6891 #else
6892     TRACE("%p, %p\n", device, pInfo);
6893     return device->funcs.p_vkGetBufferOpaqueCaptureAddress(device->device, pInfo);
6894 #endif
6895 }
6896
6897 static uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
6898 {
6899 #if defined(USE_STRUCT_CONVERSION)
6900     uint64_t result;
6901     VkBufferDeviceAddressInfo_host pInfo_host;
6902     TRACE("%p, %p\n", device, pInfo);
6903
6904     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
6905     result = device->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(device->device, &pInfo_host);
6906
6907     return result;
6908 #else
6909     TRACE("%p, %p\n", device, pInfo);
6910     return device->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(device->device, pInfo);
6911 #endif
6912 }
6913
6914 static uint32_t WINAPI wine_vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
6915 {
6916     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(operation));
6917     return device->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(device->device, operation);
6918 }
6919
6920 static VkResult WINAPI wine_vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
6921 {
6922     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(operation));
6923     return device->funcs.p_vkGetDeferredOperationResultKHR(device->device, operation);
6924 }
6925
6926 static void WINAPI wine_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
6927 {
6928     TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport);
6929     device->funcs.p_vkGetDescriptorSetLayoutSupport(device->device, pCreateInfo, pSupport);
6930 }
6931
6932 static void WINAPI wine_vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
6933 {
6934     TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport);
6935     device->funcs.p_vkGetDescriptorSetLayoutSupportKHR(device->device, pCreateInfo, pSupport);
6936 }
6937
6938 static void WINAPI wine_vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
6939 {
6940     TRACE("%p, %p, %p\n", device, pVersionInfo, pCompatibility);
6941     device->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(device->device, pVersionInfo, pCompatibility);
6942 }
6943
6944 static void WINAPI wine_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
6945 {
6946     TRACE("%p, %u, %u, %u, %p\n", device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
6947     device->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(device->device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
6948 }
6949
6950 static void WINAPI wine_vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
6951 {
6952     TRACE("%p, %u, %u, %u, %p\n", device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
6953     device->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(device->device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
6954 }
6955
6956 static VkResult WINAPI wine_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
6957 {
6958     TRACE("%p, %p\n", device, pDeviceGroupPresentCapabilities);
6959     return device->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(device->device, pDeviceGroupPresentCapabilities);
6960 }
6961
6962 static VkResult WINAPI wine_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
6963 {
6964     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(surface), pModes);
6965     return device->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(device->device, wine_surface_from_handle(surface)->driver_surface, pModes);
6966 }
6967
6968 static void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
6969 {
6970     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pCommittedMemoryInBytes);
6971     device->funcs.p_vkGetDeviceMemoryCommitment(device->device, memory, pCommittedMemoryInBytes);
6972 }
6973
6974 static uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
6975 {
6976 #if defined(USE_STRUCT_CONVERSION)
6977     uint64_t result;
6978     VkDeviceMemoryOpaqueCaptureAddressInfo_host pInfo_host;
6979     TRACE("%p, %p\n", device, pInfo);
6980
6981     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win_to_host(pInfo, &pInfo_host);
6982     result = device->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(device->device, &pInfo_host);
6983
6984     return result;
6985 #else
6986     TRACE("%p, %p\n", device, pInfo);
6987     return device->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(device->device, pInfo);
6988 #endif
6989 }
6990
6991 static uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
6992 {
6993 #if defined(USE_STRUCT_CONVERSION)
6994     uint64_t result;
6995     VkDeviceMemoryOpaqueCaptureAddressInfo_host pInfo_host;
6996     TRACE("%p, %p\n", device, pInfo);
6997
6998     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win_to_host(pInfo, &pInfo_host);
6999     result = device->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(device->device, &pInfo_host);
7000
7001     return result;
7002 #else
7003     TRACE("%p, %p\n", device, pInfo);
7004     return device->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(device->device, pInfo);
7005 #endif
7006 }
7007
7008 static VkResult WINAPI wine_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
7009 {
7010     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderpass), pMaxWorkgroupSize);
7011     return device->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device->device, renderpass, pMaxWorkgroupSize);
7012 }
7013
7014 static VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
7015 {
7016     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
7017     return device->funcs.p_vkGetEventStatus(device->device, event);
7018 }
7019
7020 static VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
7021 {
7022     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(fence));
7023     return device->funcs.p_vkGetFenceStatus(device->device, fence);
7024 }
7025
7026 static void WINAPI wine_vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
7027 {
7028 #if defined(USE_STRUCT_CONVERSION)
7029     VkGeneratedCommandsMemoryRequirementsInfoNV_host pInfo_host;
7030     VkMemoryRequirements2_host pMemoryRequirements_host;
7031     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
7032
7033     convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win_to_host(pInfo, &pInfo_host);
7034     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
7035     device->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(device->device, &pInfo_host, &pMemoryRequirements_host);
7036
7037     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
7038 #else
7039     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
7040     device->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(device->device, pInfo, pMemoryRequirements);
7041 #endif
7042 }
7043
7044 static void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
7045 {
7046 #if defined(USE_STRUCT_CONVERSION)
7047     VkMemoryRequirements_host pMemoryRequirements_host;
7048     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
7049
7050     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, &pMemoryRequirements_host);
7051
7052     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
7053 #else
7054     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
7055     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, pMemoryRequirements);
7056 #endif
7057 }
7058
7059 static void WINAPI wine_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
7060 {
7061 #if defined(USE_STRUCT_CONVERSION)
7062     VkImageMemoryRequirementsInfo2_host pInfo_host;
7063     VkMemoryRequirements2_host pMemoryRequirements_host;
7064     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
7065
7066     convert_VkImageMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
7067     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
7068     device->funcs.p_vkGetImageMemoryRequirements2(device->device, &pInfo_host, &pMemoryRequirements_host);
7069
7070     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
7071 #else
7072     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
7073     device->funcs.p_vkGetImageMemoryRequirements2(device->device, pInfo, pMemoryRequirements);
7074 #endif
7075 }
7076
7077 static void WINAPI wine_vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
7078 {
7079 #if defined(USE_STRUCT_CONVERSION)
7080     VkImageMemoryRequirementsInfo2_host pInfo_host;
7081     VkMemoryRequirements2_host pMemoryRequirements_host;
7082     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
7083
7084     convert_VkImageMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
7085     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
7086     device->funcs.p_vkGetImageMemoryRequirements2KHR(device->device, &pInfo_host, &pMemoryRequirements_host);
7087
7088     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
7089 #else
7090     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
7091     device->funcs.p_vkGetImageMemoryRequirements2KHR(device->device, pInfo, pMemoryRequirements);
7092 #endif
7093 }
7094
7095 static void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
7096 {
7097     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7098     device->funcs.p_vkGetImageSparseMemoryRequirements(device->device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7099 }
7100
7101 static void WINAPI wine_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
7102 {
7103 #if defined(USE_STRUCT_CONVERSION)
7104     VkImageSparseMemoryRequirementsInfo2_host pInfo_host;
7105     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7106
7107     convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
7108     device->funcs.p_vkGetImageSparseMemoryRequirements2(device->device, &pInfo_host, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7109
7110 #else
7111     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7112     device->funcs.p_vkGetImageSparseMemoryRequirements2(device->device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7113 #endif
7114 }
7115
7116 static void WINAPI wine_vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
7117 {
7118 #if defined(USE_STRUCT_CONVERSION)
7119     VkImageSparseMemoryRequirementsInfo2_host pInfo_host;
7120     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7121
7122     convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
7123     device->funcs.p_vkGetImageSparseMemoryRequirements2KHR(device->device, &pInfo_host, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7124
7125 #else
7126     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7127     device->funcs.p_vkGetImageSparseMemoryRequirements2KHR(device->device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
7128 #endif
7129 }
7130
7131 static void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
7132 {
7133 #if defined(USE_STRUCT_CONVERSION)
7134     VkSubresourceLayout_host pLayout_host;
7135     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
7136
7137     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, &pLayout_host);
7138
7139     convert_VkSubresourceLayout_host_to_win(&pLayout_host, pLayout);
7140 #else
7141     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
7142     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, pLayout);
7143 #endif
7144 }
7145
7146 static VkResult WINAPI wine_vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
7147 {
7148 #if defined(USE_STRUCT_CONVERSION)
7149     VkResult result;
7150     VkImageViewAddressPropertiesNVX_host pProperties_host;
7151     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(imageView), pProperties);
7152
7153     convert_VkImageViewAddressPropertiesNVX_win_to_host(pProperties, &pProperties_host);
7154     result = device->funcs.p_vkGetImageViewAddressNVX(device->device, imageView, &pProperties_host);
7155
7156     convert_VkImageViewAddressPropertiesNVX_host_to_win(&pProperties_host, pProperties);
7157     return result;
7158 #else
7159     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(imageView), pProperties);
7160     return device->funcs.p_vkGetImageViewAddressNVX(device->device, imageView, pProperties);
7161 #endif
7162 }
7163
7164 static uint32_t WINAPI wine_vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
7165 {
7166 #if defined(USE_STRUCT_CONVERSION)
7167     uint32_t result;
7168     VkImageViewHandleInfoNVX_host pInfo_host;
7169     TRACE("%p, %p\n", device, pInfo);
7170
7171     convert_VkImageViewHandleInfoNVX_win_to_host(pInfo, &pInfo_host);
7172     result = device->funcs.p_vkGetImageViewHandleNVX(device->device, &pInfo_host);
7173
7174     return result;
7175 #else
7176     TRACE("%p, %p\n", device, pInfo);
7177     return device->funcs.p_vkGetImageViewHandleNVX(device->device, pInfo);
7178 #endif
7179 }
7180
7181 static VkResult WINAPI wine_vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
7182 {
7183     TRACE("%p, %#x, %p, %p\n", device, handleType, pHostPointer, pMemoryHostPointerProperties);
7184     return device->funcs.p_vkGetMemoryHostPointerPropertiesEXT(device->device, handleType, pHostPointer, pMemoryHostPointerProperties);
7185 }
7186
7187 static VkResult WINAPI wine_vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
7188 {
7189     TRACE("%p, %#x, %p\n", device, parameter, pValue);
7190     return device->funcs.p_vkGetPerformanceParameterINTEL(device->device, parameter, pValue);
7191 }
7192
7193 static VkResult WINAPI wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
7194 {
7195     TRACE("%p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
7196     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice->phys_dev, pPropertyCount, pProperties);
7197 }
7198
7199 static void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
7200 {
7201     TRACE("%p, %p\n", physicalDevice, pFeatures);
7202     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures(physicalDevice->phys_dev, pFeatures);
7203 }
7204
7205 static void WINAPI wine_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
7206 {
7207     TRACE("%p, %p\n", physicalDevice, pFeatures);
7208     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2(physicalDevice->phys_dev, pFeatures);
7209 }
7210
7211 static void WINAPI wine_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
7212 {
7213     TRACE("%p, %p\n", physicalDevice, pFeatures);
7214     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(physicalDevice->phys_dev, pFeatures);
7215 }
7216
7217 static void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
7218 {
7219     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
7220     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(physicalDevice->phys_dev, format, pFormatProperties);
7221 }
7222
7223 static void WINAPI wine_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
7224 {
7225     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
7226     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(physicalDevice->phys_dev, format, pFormatProperties);
7227 }
7228
7229 static void WINAPI wine_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
7230 {
7231     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
7232     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice->phys_dev, format, pFormatProperties);
7233 }
7234
7235 static VkResult WINAPI wine_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
7236 {
7237     TRACE("%p, %p, %p\n", physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
7238     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice->phys_dev, pFragmentShadingRateCount, pFragmentShadingRates);
7239 }
7240
7241 static VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
7242 {
7243 #if defined(USE_STRUCT_CONVERSION)
7244     VkResult result;
7245     VkImageFormatProperties_host pImageFormatProperties_host;
7246     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
7247
7248     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, &pImageFormatProperties_host);
7249
7250     convert_VkImageFormatProperties_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
7251     return result;
7252 #else
7253     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
7254     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, pImageFormatProperties);
7255 #endif
7256 }
7257
7258 VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
7259 {
7260 #if defined(USE_STRUCT_CONVERSION)
7261     VkResult result;
7262     VkImageFormatProperties2_host pImageFormatProperties_host;
7263     convert_VkImageFormatProperties2_win_to_host(pImageFormatProperties, &pImageFormatProperties_host);
7264     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice->phys_dev, pImageFormatInfo, &pImageFormatProperties_host);
7265
7266     convert_VkImageFormatProperties2_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
7267     return result;
7268 #else
7269     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice->phys_dev, pImageFormatInfo, pImageFormatProperties);
7270 #endif
7271 }
7272
7273 VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
7274 {
7275 #if defined(USE_STRUCT_CONVERSION)
7276     VkResult result;
7277     VkImageFormatProperties2_host pImageFormatProperties_host;
7278     convert_VkImageFormatProperties2_win_to_host(pImageFormatProperties, &pImageFormatProperties_host);
7279     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice->phys_dev, pImageFormatInfo, &pImageFormatProperties_host);
7280
7281     convert_VkImageFormatProperties2_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
7282     return result;
7283 #else
7284     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice->phys_dev, pImageFormatInfo, pImageFormatProperties);
7285 #endif
7286 }
7287
7288 static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
7289 {
7290 #if defined(USE_STRUCT_CONVERSION)
7291     VkPhysicalDeviceMemoryProperties_host pMemoryProperties_host;
7292     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
7293
7294     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, &pMemoryProperties_host);
7295
7296     convert_VkPhysicalDeviceMemoryProperties_host_to_win(&pMemoryProperties_host, pMemoryProperties);
7297 #else
7298     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
7299     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, pMemoryProperties);
7300 #endif
7301 }
7302
7303 static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
7304 {
7305 #if defined(USE_STRUCT_CONVERSION)
7306     VkPhysicalDeviceMemoryProperties2_host pMemoryProperties_host;
7307     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
7308
7309     convert_VkPhysicalDeviceMemoryProperties2_win_to_host(pMemoryProperties, &pMemoryProperties_host);
7310     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice->phys_dev, &pMemoryProperties_host);
7311
7312     convert_VkPhysicalDeviceMemoryProperties2_host_to_win(&pMemoryProperties_host, pMemoryProperties);
7313 #else
7314     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
7315     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice->phys_dev, pMemoryProperties);
7316 #endif
7317 }
7318
7319 static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
7320 {
7321 #if defined(USE_STRUCT_CONVERSION)
7322     VkPhysicalDeviceMemoryProperties2_host pMemoryProperties_host;
7323     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
7324
7325     convert_VkPhysicalDeviceMemoryProperties2_win_to_host(pMemoryProperties, &pMemoryProperties_host);
7326     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice->phys_dev, &pMemoryProperties_host);
7327
7328     convert_VkPhysicalDeviceMemoryProperties2_host_to_win(&pMemoryProperties_host, pMemoryProperties);
7329 #else
7330     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
7331     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice->phys_dev, pMemoryProperties);
7332 #endif
7333 }
7334
7335 static void WINAPI wine_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
7336 {
7337     TRACE("%p, %#x, %p\n", physicalDevice, samples, pMultisampleProperties);
7338     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice->phys_dev, samples, pMultisampleProperties);
7339 }
7340
7341 static VkResult WINAPI wine_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
7342 {
7343     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pRectCount, pRects);
7344     return physicalDevice->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice->phys_dev, wine_surface_from_handle(surface)->driver_surface, pRectCount, pRects);
7345 }
7346
7347 static void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
7348 {
7349 #if defined(USE_STRUCT_CONVERSION)
7350     VkPhysicalDeviceProperties_host pProperties_host;
7351     TRACE("%p, %p\n", physicalDevice, pProperties);
7352
7353     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, &pProperties_host);
7354
7355     convert_VkPhysicalDeviceProperties_host_to_win(&pProperties_host, pProperties);
7356 #else
7357     TRACE("%p, %p\n", physicalDevice, pProperties);
7358     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, pProperties);
7359 #endif
7360 }
7361
7362 static void WINAPI wine_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
7363 {
7364 #if defined(USE_STRUCT_CONVERSION)
7365     VkPhysicalDeviceProperties2_host pProperties_host;
7366     TRACE("%p, %p\n", physicalDevice, pProperties);
7367
7368     convert_VkPhysicalDeviceProperties2_win_to_host(pProperties, &pProperties_host);
7369     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2(physicalDevice->phys_dev, &pProperties_host);
7370
7371     convert_VkPhysicalDeviceProperties2_host_to_win(&pProperties_host, pProperties);
7372 #else
7373     TRACE("%p, %p\n", physicalDevice, pProperties);
7374     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2(physicalDevice->phys_dev, pProperties);
7375 #endif
7376 }
7377
7378 static void WINAPI wine_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
7379 {
7380 #if defined(USE_STRUCT_CONVERSION)
7381     VkPhysicalDeviceProperties2_host pProperties_host;
7382     TRACE("%p, %p\n", physicalDevice, pProperties);
7383
7384     convert_VkPhysicalDeviceProperties2_win_to_host(pProperties, &pProperties_host);
7385     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(physicalDevice->phys_dev, &pProperties_host);
7386
7387     convert_VkPhysicalDeviceProperties2_host_to_win(&pProperties_host, pProperties);
7388 #else
7389     TRACE("%p, %p\n", physicalDevice, pProperties);
7390     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(physicalDevice->phys_dev, pProperties);
7391 #endif
7392 }
7393
7394 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
7395 {
7396     TRACE("%p, %p, %p\n", physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
7397     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice->phys_dev, pPerformanceQueryCreateInfo, pNumPasses);
7398 }
7399
7400 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
7401 {
7402     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
7403     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
7404 }
7405
7406 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
7407 {
7408     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
7409     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
7410 }
7411
7412 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
7413 {
7414     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
7415     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
7416 }
7417
7418 static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
7419 {
7420     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p, %p\n", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
7421     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice->phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties);
7422 }
7423
7424 static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
7425 {
7426     TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties);
7427     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
7428 }
7429
7430 static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
7431 {
7432     TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties);
7433     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
7434 }
7435
7436 static VkResult WINAPI wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
7437 {
7438     TRACE("%p, %p, %p\n", physicalDevice, pCombinationCount, pCombinations);
7439     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice->phys_dev, pCombinationCount, pCombinations);
7440 }
7441
7442 VkResult thunk_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
7443 {
7444 #if defined(USE_STRUCT_CONVERSION)
7445     VkResult result;
7446     VkPhysicalDeviceSurfaceInfo2KHR_host pSurfaceInfo_host;
7447     convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(pSurfaceInfo, &pSurfaceInfo_host);
7448     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice->phys_dev, &pSurfaceInfo_host, pSurfaceCapabilities);
7449
7450     return result;
7451 #else
7452     VkResult result;
7453     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
7454     convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(pSurfaceInfo, &pSurfaceInfo_host);
7455     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice->phys_dev, &pSurfaceInfo_host, pSurfaceCapabilities);
7456
7457     return result;
7458 #endif
7459 }
7460
7461 VkResult thunk_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
7462 {
7463     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice->phys_dev, wine_surface_from_handle(surface)->driver_surface, pSurfaceCapabilities);
7464 }
7465
7466 static VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
7467 {
7468 #if defined(USE_STRUCT_CONVERSION)
7469     VkResult result;
7470     VkPhysicalDeviceSurfaceInfo2KHR_host pSurfaceInfo_host;
7471     TRACE("%p, %p, %p, %p\n", physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
7472
7473     convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(pSurfaceInfo, &pSurfaceInfo_host);
7474     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice->phys_dev, &pSurfaceInfo_host, pSurfaceFormatCount, pSurfaceFormats);
7475
7476     return result;
7477 #else
7478     VkResult result;
7479     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
7480     TRACE("%p, %p, %p, %p\n", physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
7481
7482     convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(pSurfaceInfo, &pSurfaceInfo_host);
7483     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice->phys_dev, &pSurfaceInfo_host, pSurfaceFormatCount, pSurfaceFormats);
7484
7485     return result;
7486 #endif
7487 }
7488
7489 static VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
7490 {
7491     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pSurfaceFormatCount, pSurfaceFormats);
7492     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice->phys_dev, wine_surface_from_handle(surface)->driver_surface, pSurfaceFormatCount, pSurfaceFormats);
7493 }
7494
7495 static VkResult WINAPI wine_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
7496 {
7497     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pPresentModeCount, pPresentModes);
7498     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice->phys_dev, wine_surface_from_handle(surface)->driver_surface, pPresentModeCount, pPresentModes);
7499 }
7500
7501 static VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
7502 {
7503     TRACE("%p, %u, 0x%s, %p\n", physicalDevice, queueFamilyIndex, wine_dbgstr_longlong(surface), pSupported);
7504     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice->phys_dev, queueFamilyIndex, wine_surface_from_handle(surface)->driver_surface, pSupported);
7505 }
7506
7507 static VkResult WINAPI wine_vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolPropertiesEXT *pToolProperties)
7508 {
7509     TRACE("%p, %p, %p\n", physicalDevice, pToolCount, pToolProperties);
7510     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice->phys_dev, pToolCount, pToolProperties);
7511 }
7512
7513 static VkBool32 WINAPI wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
7514 {
7515     TRACE("%p, %u\n", physicalDevice, queueFamilyIndex);
7516     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice->phys_dev, queueFamilyIndex);
7517 }
7518
7519 static VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
7520 {
7521     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), pDataSize, pData);
7522     return device->funcs.p_vkGetPipelineCacheData(device->device, pipelineCache, pDataSize, pData);
7523 }
7524
7525 static VkResult WINAPI wine_vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
7526 {
7527 #if defined(USE_STRUCT_CONVERSION)
7528     VkResult result;
7529     VkPipelineExecutableInfoKHR_host pExecutableInfo_host;
7530     TRACE("%p, %p, %p, %p\n", device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
7531
7532     convert_VkPipelineExecutableInfoKHR_win_to_host(pExecutableInfo, &pExecutableInfo_host);
7533     result = device->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(device->device, &pExecutableInfo_host, pInternalRepresentationCount, pInternalRepresentations);
7534
7535     return result;
7536 #else
7537     TRACE("%p, %p, %p, %p\n", device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
7538     return device->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(device->device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
7539 #endif
7540 }
7541
7542 static VkResult WINAPI wine_vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
7543 {
7544 #if defined(USE_STRUCT_CONVERSION)
7545     VkResult result;
7546     VkPipelineInfoKHR_host pPipelineInfo_host;
7547     TRACE("%p, %p, %p, %p\n", device, pPipelineInfo, pExecutableCount, pProperties);
7548
7549     convert_VkPipelineInfoKHR_win_to_host(pPipelineInfo, &pPipelineInfo_host);
7550     result = device->funcs.p_vkGetPipelineExecutablePropertiesKHR(device->device, &pPipelineInfo_host, pExecutableCount, pProperties);
7551
7552     return result;
7553 #else
7554     TRACE("%p, %p, %p, %p\n", device, pPipelineInfo, pExecutableCount, pProperties);
7555     return device->funcs.p_vkGetPipelineExecutablePropertiesKHR(device->device, pPipelineInfo, pExecutableCount, pProperties);
7556 #endif
7557 }
7558
7559 static VkResult WINAPI wine_vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
7560 {
7561 #if defined(USE_STRUCT_CONVERSION)
7562     VkResult result;
7563     VkPipelineExecutableInfoKHR_host pExecutableInfo_host;
7564     TRACE("%p, %p, %p, %p\n", device, pExecutableInfo, pStatisticCount, pStatistics);
7565
7566     convert_VkPipelineExecutableInfoKHR_win_to_host(pExecutableInfo, &pExecutableInfo_host);
7567     result = device->funcs.p_vkGetPipelineExecutableStatisticsKHR(device->device, &pExecutableInfo_host, pStatisticCount, pStatistics);
7568
7569     return result;
7570 #else
7571     TRACE("%p, %p, %p, %p\n", device, pExecutableInfo, pStatisticCount, pStatistics);
7572     return device->funcs.p_vkGetPipelineExecutableStatisticsKHR(device->device, pExecutableInfo, pStatisticCount, pStatistics);
7573 #endif
7574 }
7575
7576 static void WINAPI wine_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t *pData)
7577 {
7578     TRACE("%p, %#x, 0x%s, 0x%s, %p\n", device, objectType, wine_dbgstr_longlong(objectHandle), wine_dbgstr_longlong(privateDataSlot), pData);
7579     device->funcs.p_vkGetPrivateDataEXT(device->device, objectType, wine_vk_unwrap_handle(objectType, objectHandle), privateDataSlot, pData);
7580 }
7581
7582 static VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
7583 {
7584     TRACE("%p, 0x%s, %u, %u, 0x%s, %p, 0x%s, %#x\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount, wine_dbgstr_longlong(dataSize), pData, wine_dbgstr_longlong(stride), flags);
7585     return device->funcs.p_vkGetQueryPoolResults(device->device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
7586 }
7587
7588 static void WINAPI wine_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
7589 {
7590     TRACE("%p, %p, %p\n", queue, pCheckpointDataCount, pCheckpointData);
7591     queue->device->funcs.p_vkGetQueueCheckpointData2NV(queue->queue, pCheckpointDataCount, pCheckpointData);
7592 }
7593
7594 static void WINAPI wine_vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
7595 {
7596     TRACE("%p, %p, %p\n", queue, pCheckpointDataCount, pCheckpointData);
7597     queue->device->funcs.p_vkGetQueueCheckpointDataNV(queue->queue, pCheckpointDataCount, pCheckpointData);
7598 }
7599
7600 static VkResult WINAPI wine_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
7601 {
7602     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), firstGroup, groupCount, wine_dbgstr_longlong(dataSize), pData);
7603     return device->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device->device, pipeline, firstGroup, groupCount, dataSize, pData);
7604 }
7605
7606 static VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
7607 {
7608     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), firstGroup, groupCount, wine_dbgstr_longlong(dataSize), pData);
7609     return device->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(device->device, pipeline, firstGroup, groupCount, dataSize, pData);
7610 }
7611
7612 static VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
7613 {
7614     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), firstGroup, groupCount, wine_dbgstr_longlong(dataSize), pData);
7615     return device->funcs.p_vkGetRayTracingShaderGroupHandlesNV(device->device, pipeline, firstGroup, groupCount, dataSize, pData);
7616 }
7617
7618 static VkDeviceSize WINAPI wine_vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
7619 {
7620     TRACE("%p, 0x%s, %u, %#x\n", device, wine_dbgstr_longlong(pipeline), group, groupShader);
7621     return device->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(device->device, pipeline, group, groupShader);
7622 }
7623
7624 static void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
7625 {
7626     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pGranularity);
7627     device->funcs.p_vkGetRenderAreaGranularity(device->device, renderPass, pGranularity);
7628 }
7629
7630 static VkResult WINAPI wine_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
7631 {
7632     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pValue);
7633     return device->funcs.p_vkGetSemaphoreCounterValue(device->device, semaphore, pValue);
7634 }
7635
7636 static VkResult WINAPI wine_vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
7637 {
7638     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pValue);
7639     return device->funcs.p_vkGetSemaphoreCounterValueKHR(device->device, semaphore, pValue);
7640 }
7641
7642 static VkResult WINAPI wine_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
7643 {
7644     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", device, wine_dbgstr_longlong(pipeline), shaderStage, infoType, pInfoSize, pInfo);
7645     return device->funcs.p_vkGetShaderInfoAMD(device->device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
7646 }
7647
7648 static VkResult WINAPI wine_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
7649 {
7650     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(swapchain), pSwapchainImageCount, pSwapchainImages);
7651     return device->funcs.p_vkGetSwapchainImagesKHR(device->device, swapchain, pSwapchainImageCount, pSwapchainImages);
7652 }
7653
7654 static VkResult WINAPI wine_vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
7655 {
7656     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(validationCache), pDataSize, pData);
7657     return device->funcs.p_vkGetValidationCacheDataEXT(device->device, validationCache, pDataSize, pData);
7658 }
7659
7660 static VkResult WINAPI wine_vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
7661 {
7662     TRACE("%p, %p\n", device, pInitializeInfo);
7663     return device->funcs.p_vkInitializePerformanceApiINTEL(device->device, pInitializeInfo);
7664 }
7665
7666 static VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
7667 {
7668 #if defined(USE_STRUCT_CONVERSION)
7669     VkResult result;
7670     VkMappedMemoryRange_host *pMemoryRanges_host;
7671     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
7672
7673     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
7674     result = device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
7675
7676     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
7677     return result;
7678 #else
7679     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
7680     return device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
7681 #endif
7682 }
7683
7684 static VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
7685 {
7686     TRACE("%p, 0x%s, 0x%s, 0x%s, %#x, %p\n", device, wine_dbgstr_longlong(memory), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size), flags, ppData);
7687     return device->funcs.p_vkMapMemory(device->device, memory, offset, size, flags, ppData);
7688 }
7689
7690 static VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
7691 {
7692     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
7693     return device->funcs.p_vkMergePipelineCaches(device->device, dstCache, srcCacheCount, pSrcCaches);
7694 }
7695
7696 static VkResult WINAPI wine_vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
7697 {
7698     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
7699     return device->funcs.p_vkMergeValidationCachesEXT(device->device, dstCache, srcCacheCount, pSrcCaches);
7700 }
7701
7702 static void WINAPI wine_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
7703 {
7704     TRACE("%p, %p\n", queue, pLabelInfo);
7705     queue->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(queue->queue, pLabelInfo);
7706 }
7707
7708 static VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
7709 {
7710 #if defined(USE_STRUCT_CONVERSION)
7711     VkResult result;
7712     VkBindSparseInfo_host *pBindInfo_host;
7713     TRACE("%p, %u, %p, 0x%s\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence));
7714
7715     pBindInfo_host = convert_VkBindSparseInfo_array_win_to_host(pBindInfo, bindInfoCount);
7716     result = queue->device->funcs.p_vkQueueBindSparse(queue->queue, bindInfoCount, pBindInfo_host, fence);
7717
7718     free_VkBindSparseInfo_array(pBindInfo_host, bindInfoCount);
7719     return result;
7720 #else
7721     TRACE("%p, %u, %p, 0x%s\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence));
7722     return queue->device->funcs.p_vkQueueBindSparse(queue->queue, bindInfoCount, pBindInfo, fence);
7723 #endif
7724 }
7725
7726 static void WINAPI wine_vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
7727 {
7728     TRACE("%p\n", queue);
7729     queue->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(queue->queue);
7730 }
7731
7732 static void WINAPI wine_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
7733 {
7734     TRACE("%p, %p\n", queue, pLabelInfo);
7735     queue->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(queue->queue, pLabelInfo);
7736 }
7737
7738 static VkResult WINAPI wine_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
7739 {
7740     TRACE("%p, %p\n", queue, pPresentInfo);
7741     return queue->device->funcs.p_vkQueuePresentKHR(queue->queue, pPresentInfo);
7742 }
7743
7744 static VkResult WINAPI wine_vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
7745 {
7746     TRACE("%p, 0x%s\n", queue, wine_dbgstr_longlong(configuration));
7747     return queue->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(queue->queue, configuration);
7748 }
7749
7750 static VkResult WINAPI wine_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
7751 {
7752     VkResult result;
7753     VkSubmitInfo *pSubmits_host;
7754     TRACE("%p, %u, %p, 0x%s\n", queue, submitCount, pSubmits, wine_dbgstr_longlong(fence));
7755
7756     pSubmits_host = convert_VkSubmitInfo_array_win_to_host(pSubmits, submitCount);
7757     result = queue->device->funcs.p_vkQueueSubmit(queue->queue, submitCount, pSubmits_host, fence);
7758
7759     free_VkSubmitInfo_array(pSubmits_host, submitCount);
7760     return result;
7761 }
7762
7763 static VkResult WINAPI wine_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR *pSubmits, VkFence fence)
7764 {
7765 #if defined(USE_STRUCT_CONVERSION)
7766     VkResult result;
7767     VkSubmitInfo2KHR_host *pSubmits_host;
7768     TRACE("%p, %u, %p, 0x%s\n", queue, submitCount, pSubmits, wine_dbgstr_longlong(fence));
7769
7770     pSubmits_host = convert_VkSubmitInfo2KHR_array_win_to_host(pSubmits, submitCount);
7771     result = queue->device->funcs.p_vkQueueSubmit2KHR(queue->queue, submitCount, pSubmits_host, fence);
7772
7773     free_VkSubmitInfo2KHR_array(pSubmits_host, submitCount);
7774     return result;
7775 #else
7776     VkResult result;
7777     VkSubmitInfo2KHR *pSubmits_host;
7778     TRACE("%p, %u, %p, 0x%s\n", queue, submitCount, pSubmits, wine_dbgstr_longlong(fence));
7779
7780     pSubmits_host = convert_VkSubmitInfo2KHR_array_win_to_host(pSubmits, submitCount);
7781     result = queue->device->funcs.p_vkQueueSubmit2KHR(queue->queue, submitCount, pSubmits_host, fence);
7782
7783     free_VkSubmitInfo2KHR_array(pSubmits_host, submitCount);
7784     return result;
7785 #endif
7786 }
7787
7788 static VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
7789 {
7790     TRACE("%p\n", queue);
7791     return queue->device->funcs.p_vkQueueWaitIdle(queue->queue);
7792 }
7793
7794 static VkResult WINAPI wine_vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
7795 {
7796     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(configuration));
7797     return device->funcs.p_vkReleasePerformanceConfigurationINTEL(device->device, configuration);
7798 }
7799
7800 static void WINAPI wine_vkReleaseProfilingLockKHR(VkDevice device)
7801 {
7802     TRACE("%p\n", device);
7803     device->funcs.p_vkReleaseProfilingLockKHR(device->device);
7804 }
7805
7806 static VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
7807 {
7808     TRACE("%p, %#x\n", commandBuffer, flags);
7809     return commandBuffer->device->funcs.p_vkResetCommandBuffer(commandBuffer->command_buffer, flags);
7810 }
7811
7812 static VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
7813 {
7814     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
7815     return device->funcs.p_vkResetCommandPool(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
7816 }
7817
7818 static VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
7819 {
7820     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(descriptorPool), flags);
7821     return device->funcs.p_vkResetDescriptorPool(device->device, descriptorPool, flags);
7822 }
7823
7824 static VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
7825 {
7826     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
7827     return device->funcs.p_vkResetEvent(device->device, event);
7828 }
7829
7830 static VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
7831 {
7832     TRACE("%p, %u, %p\n", device, fenceCount, pFences);
7833     return device->funcs.p_vkResetFences(device->device, fenceCount, pFences);
7834 }
7835
7836 static void WINAPI wine_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
7837 {
7838     TRACE("%p, 0x%s, %u, %u\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
7839     device->funcs.p_vkResetQueryPool(device->device, queryPool, firstQuery, queryCount);
7840 }
7841
7842 static void WINAPI wine_vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
7843 {
7844     TRACE("%p, 0x%s, %u, %u\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
7845     device->funcs.p_vkResetQueryPoolEXT(device->device, queryPool, firstQuery, queryCount);
7846 }
7847
7848 static VkResult WINAPI wine_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
7849 {
7850 #if defined(USE_STRUCT_CONVERSION)
7851     VkResult result;
7852     VkDebugUtilsObjectNameInfoEXT_host pNameInfo_host;
7853     TRACE("%p, %p\n", device, pNameInfo);
7854
7855     convert_VkDebugUtilsObjectNameInfoEXT_win_to_host(pNameInfo, &pNameInfo_host);
7856     result = device->funcs.p_vkSetDebugUtilsObjectNameEXT(device->device, &pNameInfo_host);
7857
7858     return result;
7859 #else
7860     VkResult result;
7861     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
7862     TRACE("%p, %p\n", device, pNameInfo);
7863
7864     convert_VkDebugUtilsObjectNameInfoEXT_win_to_host(pNameInfo, &pNameInfo_host);
7865     result = device->funcs.p_vkSetDebugUtilsObjectNameEXT(device->device, &pNameInfo_host);
7866
7867     return result;
7868 #endif
7869 }
7870
7871 static VkResult WINAPI wine_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
7872 {
7873 #if defined(USE_STRUCT_CONVERSION)
7874     VkResult result;
7875     VkDebugUtilsObjectTagInfoEXT_host pTagInfo_host;
7876     TRACE("%p, %p\n", device, pTagInfo);
7877
7878     convert_VkDebugUtilsObjectTagInfoEXT_win_to_host(pTagInfo, &pTagInfo_host);
7879     result = device->funcs.p_vkSetDebugUtilsObjectTagEXT(device->device, &pTagInfo_host);
7880
7881     return result;
7882 #else
7883     VkResult result;
7884     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
7885     TRACE("%p, %p\n", device, pTagInfo);
7886
7887     convert_VkDebugUtilsObjectTagInfoEXT_win_to_host(pTagInfo, &pTagInfo_host);
7888     result = device->funcs.p_vkSetDebugUtilsObjectTagEXT(device->device, &pTagInfo_host);
7889
7890     return result;
7891 #endif
7892 }
7893
7894 static VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
7895 {
7896     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
7897     return device->funcs.p_vkSetEvent(device->device, event);
7898 }
7899
7900 static VkResult WINAPI wine_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data)
7901 {
7902     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", device, objectType, wine_dbgstr_longlong(objectHandle), wine_dbgstr_longlong(privateDataSlot), wine_dbgstr_longlong(data));
7903     return device->funcs.p_vkSetPrivateDataEXT(device->device, objectType, wine_vk_unwrap_handle(objectType, objectHandle), privateDataSlot, data);
7904 }
7905
7906 static VkResult WINAPI wine_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
7907 {
7908 #if defined(USE_STRUCT_CONVERSION)
7909     VkResult result;
7910     VkSemaphoreSignalInfo_host pSignalInfo_host;
7911     TRACE("%p, %p\n", device, pSignalInfo);
7912
7913     convert_VkSemaphoreSignalInfo_win_to_host(pSignalInfo, &pSignalInfo_host);
7914     result = device->funcs.p_vkSignalSemaphore(device->device, &pSignalInfo_host);
7915
7916     return result;
7917 #else
7918     TRACE("%p, %p\n", device, pSignalInfo);
7919     return device->funcs.p_vkSignalSemaphore(device->device, pSignalInfo);
7920 #endif
7921 }
7922
7923 static VkResult WINAPI wine_vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
7924 {
7925 #if defined(USE_STRUCT_CONVERSION)
7926     VkResult result;
7927     VkSemaphoreSignalInfo_host pSignalInfo_host;
7928     TRACE("%p, %p\n", device, pSignalInfo);
7929
7930     convert_VkSemaphoreSignalInfo_win_to_host(pSignalInfo, &pSignalInfo_host);
7931     result = device->funcs.p_vkSignalSemaphoreKHR(device->device, &pSignalInfo_host);
7932
7933     return result;
7934 #else
7935     TRACE("%p, %p\n", device, pSignalInfo);
7936     return device->funcs.p_vkSignalSemaphoreKHR(device->device, pSignalInfo);
7937 #endif
7938 }
7939
7940 static void WINAPI wine_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
7941 {
7942 #if defined(USE_STRUCT_CONVERSION)
7943     VkDebugUtilsMessengerCallbackDataEXT_host pCallbackData_host;
7944     TRACE("%p, %#x, %#x, %p\n", instance, messageSeverity, messageTypes, pCallbackData);
7945
7946     convert_VkDebugUtilsMessengerCallbackDataEXT_win_to_host(pCallbackData, &pCallbackData_host);
7947     instance->funcs.p_vkSubmitDebugUtilsMessageEXT(instance->instance, messageSeverity, messageTypes, &pCallbackData_host);
7948
7949     free_VkDebugUtilsMessengerCallbackDataEXT(&pCallbackData_host);
7950 #else
7951     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
7952     TRACE("%p, %#x, %#x, %p\n", instance, messageSeverity, messageTypes, pCallbackData);
7953
7954     convert_VkDebugUtilsMessengerCallbackDataEXT_win_to_host(pCallbackData, &pCallbackData_host);
7955     instance->funcs.p_vkSubmitDebugUtilsMessageEXT(instance->instance, messageSeverity, messageTypes, &pCallbackData_host);
7956
7957     free_VkDebugUtilsMessengerCallbackDataEXT(&pCallbackData_host);
7958 #endif
7959 }
7960
7961 static void WINAPI wine_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
7962 {
7963     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
7964     device->funcs.p_vkTrimCommandPool(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
7965 }
7966
7967 static void WINAPI wine_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
7968 {
7969     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
7970     device->funcs.p_vkTrimCommandPoolKHR(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
7971 }
7972
7973 static void WINAPI wine_vkUninitializePerformanceApiINTEL(VkDevice device)
7974 {
7975     TRACE("%p\n", device);
7976     device->funcs.p_vkUninitializePerformanceApiINTEL(device->device);
7977 }
7978
7979 static void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
7980 {
7981     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(memory));
7982     device->funcs.p_vkUnmapMemory(device->device, memory);
7983 }
7984
7985 static void WINAPI wine_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
7986 {
7987     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData);
7988     device->funcs.p_vkUpdateDescriptorSetWithTemplate(device->device, descriptorSet, descriptorUpdateTemplate, pData);
7989 }
7990
7991 static void WINAPI wine_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
7992 {
7993     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData);
7994     device->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(device->device, descriptorSet, descriptorUpdateTemplate, pData);
7995 }
7996
7997 static void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
7998 {
7999 #if defined(USE_STRUCT_CONVERSION)
8000     VkWriteDescriptorSet_host *pDescriptorWrites_host;
8001     VkCopyDescriptorSet_host *pDescriptorCopies_host;
8002     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
8003
8004     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win_to_host(pDescriptorWrites, descriptorWriteCount);
8005     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win_to_host(pDescriptorCopies, descriptorCopyCount);
8006     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites_host, descriptorCopyCount, pDescriptorCopies_host);
8007
8008     free_VkWriteDescriptorSet_array(pDescriptorWrites_host, descriptorWriteCount);
8009     free_VkCopyDescriptorSet_array(pDescriptorCopies_host, descriptorCopyCount);
8010 #else
8011     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
8012     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
8013 #endif
8014 }
8015
8016 static VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
8017 {
8018     TRACE("%p, %u, %p, %u, 0x%s\n", device, fenceCount, pFences, waitAll, wine_dbgstr_longlong(timeout));
8019     return device->funcs.p_vkWaitForFences(device->device, fenceCount, pFences, waitAll, timeout);
8020 }
8021
8022 static VkResult WINAPI wine_vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
8023 {
8024     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(swapchain), wine_dbgstr_longlong(presentId), wine_dbgstr_longlong(timeout));
8025     return device->funcs.p_vkWaitForPresentKHR(device->device, swapchain, presentId, timeout);
8026 }
8027
8028 static VkResult WINAPI wine_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
8029 {
8030     TRACE("%p, %p, 0x%s\n", device, pWaitInfo, wine_dbgstr_longlong(timeout));
8031     return device->funcs.p_vkWaitSemaphores(device->device, pWaitInfo, timeout);
8032 }
8033
8034 static VkResult WINAPI wine_vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
8035 {
8036     TRACE("%p, %p, 0x%s\n", device, pWaitInfo, wine_dbgstr_longlong(timeout));
8037     return device->funcs.p_vkWaitSemaphoresKHR(device->device, pWaitInfo, timeout);
8038 }
8039
8040 static VkResult WINAPI wine_vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
8041 {
8042     TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", device, accelerationStructureCount, pAccelerationStructures, queryType, wine_dbgstr_longlong(dataSize), pData, wine_dbgstr_longlong(stride));
8043     return device->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(device->device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
8044 }
8045
8046 static const char * const vk_device_extensions[] =
8047 {
8048     "VK_AMD_buffer_marker",
8049     "VK_AMD_device_coherent_memory",
8050     "VK_AMD_draw_indirect_count",
8051     "VK_AMD_gcn_shader",
8052     "VK_AMD_gpu_shader_half_float",
8053     "VK_AMD_gpu_shader_int16",
8054     "VK_AMD_memory_overallocation_behavior",
8055     "VK_AMD_mixed_attachment_samples",
8056     "VK_AMD_negative_viewport_height",
8057     "VK_AMD_pipeline_compiler_control",
8058     "VK_AMD_rasterization_order",
8059     "VK_AMD_shader_ballot",
8060     "VK_AMD_shader_core_properties",
8061     "VK_AMD_shader_core_properties2",
8062     "VK_AMD_shader_explicit_vertex_parameter",
8063     "VK_AMD_shader_fragment_mask",
8064     "VK_AMD_shader_image_load_store_lod",
8065     "VK_AMD_shader_info",
8066     "VK_AMD_shader_trinary_minmax",
8067     "VK_AMD_texture_gather_bias_lod",
8068     "VK_EXT_4444_formats",
8069     "VK_EXT_astc_decode_mode",
8070     "VK_EXT_blend_operation_advanced",
8071     "VK_EXT_buffer_device_address",
8072     "VK_EXT_calibrated_timestamps",
8073     "VK_EXT_color_write_enable",
8074     "VK_EXT_conditional_rendering",
8075     "VK_EXT_conservative_rasterization",
8076     "VK_EXT_custom_border_color",
8077     "VK_EXT_debug_marker",
8078     "VK_EXT_depth_clip_enable",
8079     "VK_EXT_depth_range_unrestricted",
8080     "VK_EXT_descriptor_indexing",
8081     "VK_EXT_discard_rectangles",
8082     "VK_EXT_extended_dynamic_state",
8083     "VK_EXT_extended_dynamic_state2",
8084     "VK_EXT_external_memory_host",
8085     "VK_EXT_filter_cubic",
8086     "VK_EXT_fragment_density_map",
8087     "VK_EXT_fragment_density_map2",
8088     "VK_EXT_fragment_shader_interlock",
8089     "VK_EXT_global_priority",
8090     "VK_EXT_global_priority_query",
8091     "VK_EXT_host_query_reset",
8092     "VK_EXT_image_robustness",
8093     "VK_EXT_index_type_uint8",
8094     "VK_EXT_inline_uniform_block",
8095     "VK_EXT_line_rasterization",
8096     "VK_EXT_load_store_op_none",
8097     "VK_EXT_memory_budget",
8098     "VK_EXT_memory_priority",
8099     "VK_EXT_multi_draw",
8100     "VK_EXT_pci_bus_info",
8101     "VK_EXT_pipeline_creation_cache_control",
8102     "VK_EXT_post_depth_coverage",
8103     "VK_EXT_private_data",
8104     "VK_EXT_provoking_vertex",
8105     "VK_EXT_queue_family_foreign",
8106     "VK_EXT_robustness2",
8107     "VK_EXT_sample_locations",
8108     "VK_EXT_sampler_filter_minmax",
8109     "VK_EXT_scalar_block_layout",
8110     "VK_EXT_separate_stencil_usage",
8111     "VK_EXT_shader_atomic_float",
8112     "VK_EXT_shader_atomic_float2",
8113     "VK_EXT_shader_demote_to_helper_invocation",
8114     "VK_EXT_shader_image_atomic_int64",
8115     "VK_EXT_shader_stencil_export",
8116     "VK_EXT_shader_subgroup_ballot",
8117     "VK_EXT_shader_subgroup_vote",
8118     "VK_EXT_shader_viewport_index_layer",
8119     "VK_EXT_subgroup_size_control",
8120     "VK_EXT_texel_buffer_alignment",
8121     "VK_EXT_texture_compression_astc_hdr",
8122     "VK_EXT_tooling_info",
8123     "VK_EXT_transform_feedback",
8124     "VK_EXT_validation_cache",
8125     "VK_EXT_vertex_attribute_divisor",
8126     "VK_EXT_vertex_input_dynamic_state",
8127     "VK_EXT_ycbcr_2plane_444_formats",
8128     "VK_EXT_ycbcr_image_arrays",
8129     "VK_GOOGLE_decorate_string",
8130     "VK_GOOGLE_hlsl_functionality1",
8131     "VK_GOOGLE_user_type",
8132     "VK_HUAWEI_invocation_mask",
8133     "VK_HUAWEI_subpass_shading",
8134     "VK_IMG_filter_cubic",
8135     "VK_IMG_format_pvrtc",
8136     "VK_INTEL_performance_query",
8137     "VK_INTEL_shader_integer_functions2",
8138     "VK_KHR_16bit_storage",
8139     "VK_KHR_8bit_storage",
8140     "VK_KHR_acceleration_structure",
8141     "VK_KHR_bind_memory2",
8142     "VK_KHR_buffer_device_address",
8143     "VK_KHR_copy_commands2",
8144     "VK_KHR_create_renderpass2",
8145     "VK_KHR_dedicated_allocation",
8146     "VK_KHR_deferred_host_operations",
8147     "VK_KHR_depth_stencil_resolve",
8148     "VK_KHR_descriptor_update_template",
8149     "VK_KHR_device_group",
8150     "VK_KHR_draw_indirect_count",
8151     "VK_KHR_driver_properties",
8152     "VK_KHR_external_fence",
8153     "VK_KHR_external_memory",
8154     "VK_KHR_external_semaphore",
8155     "VK_KHR_fragment_shading_rate",
8156     "VK_KHR_get_memory_requirements2",
8157     "VK_KHR_image_format_list",
8158     "VK_KHR_imageless_framebuffer",
8159     "VK_KHR_incremental_present",
8160     "VK_KHR_maintenance1",
8161     "VK_KHR_maintenance2",
8162     "VK_KHR_maintenance3",
8163     "VK_KHR_multiview",
8164     "VK_KHR_performance_query",
8165     "VK_KHR_pipeline_executable_properties",
8166     "VK_KHR_pipeline_library",
8167     "VK_KHR_present_id",
8168     "VK_KHR_present_wait",
8169     "VK_KHR_push_descriptor",
8170     "VK_KHR_ray_query",
8171     "VK_KHR_ray_tracing_pipeline",
8172     "VK_KHR_relaxed_block_layout",
8173     "VK_KHR_sampler_mirror_clamp_to_edge",
8174     "VK_KHR_sampler_ycbcr_conversion",
8175     "VK_KHR_separate_depth_stencil_layouts",
8176     "VK_KHR_shader_atomic_int64",
8177     "VK_KHR_shader_clock",
8178     "VK_KHR_shader_draw_parameters",
8179     "VK_KHR_shader_float16_int8",
8180     "VK_KHR_shader_float_controls",
8181     "VK_KHR_shader_non_semantic_info",
8182     "VK_KHR_shader_subgroup_extended_types",
8183     "VK_KHR_shader_subgroup_uniform_control_flow",
8184     "VK_KHR_shader_terminate_invocation",
8185     "VK_KHR_spirv_1_4",
8186     "VK_KHR_storage_buffer_storage_class",
8187     "VK_KHR_swapchain",
8188     "VK_KHR_swapchain_mutable_format",
8189     "VK_KHR_synchronization2",
8190     "VK_KHR_timeline_semaphore",
8191     "VK_KHR_uniform_buffer_standard_layout",
8192     "VK_KHR_variable_pointers",
8193     "VK_KHR_vulkan_memory_model",
8194     "VK_KHR_workgroup_memory_explicit_layout",
8195     "VK_KHR_zero_initialize_workgroup_memory",
8196     "VK_NVX_binary_import",
8197     "VK_NVX_image_view_handle",
8198     "VK_NV_clip_space_w_scaling",
8199     "VK_NV_compute_shader_derivatives",
8200     "VK_NV_cooperative_matrix",
8201     "VK_NV_corner_sampled_image",
8202     "VK_NV_coverage_reduction_mode",
8203     "VK_NV_dedicated_allocation",
8204     "VK_NV_dedicated_allocation_image_aliasing",
8205     "VK_NV_device_diagnostic_checkpoints",
8206     "VK_NV_device_diagnostics_config",
8207     "VK_NV_device_generated_commands",
8208     "VK_NV_fill_rectangle",
8209     "VK_NV_fragment_coverage_to_color",
8210     "VK_NV_fragment_shader_barycentric",
8211     "VK_NV_fragment_shading_rate_enums",
8212     "VK_NV_framebuffer_mixed_samples",
8213     "VK_NV_geometry_shader_passthrough",
8214     "VK_NV_glsl_shader",
8215     "VK_NV_inherited_viewport_scissor",
8216     "VK_NV_mesh_shader",
8217     "VK_NV_ray_tracing",
8218     "VK_NV_ray_tracing_motion_blur",
8219     "VK_NV_representative_fragment_test",
8220     "VK_NV_sample_mask_override_coverage",
8221     "VK_NV_scissor_exclusive",
8222     "VK_NV_shader_image_footprint",
8223     "VK_NV_shader_sm_builtins",
8224     "VK_NV_shader_subgroup_partitioned",
8225     "VK_NV_shading_rate_image",
8226     "VK_NV_viewport_array2",
8227     "VK_NV_viewport_swizzle",
8228     "VK_QCOM_render_pass_shader_resolve",
8229     "VK_QCOM_render_pass_store_ops",
8230     "VK_QCOM_render_pass_transform",
8231     "VK_QCOM_rotated_copy_commands",
8232     "VK_VALVE_mutable_descriptor_type",
8233 };
8234
8235 static const char * const vk_instance_extensions[] =
8236 {
8237     "VK_EXT_debug_report",
8238     "VK_EXT_debug_utils",
8239     "VK_EXT_swapchain_colorspace",
8240     "VK_EXT_validation_features",
8241     "VK_EXT_validation_flags",
8242     "VK_KHR_device_group_creation",
8243     "VK_KHR_external_fence_capabilities",
8244     "VK_KHR_external_memory_capabilities",
8245     "VK_KHR_external_semaphore_capabilities",
8246     "VK_KHR_get_physical_device_properties2",
8247     "VK_KHR_get_surface_capabilities2",
8248     "VK_KHR_surface",
8249     "VK_KHR_win32_surface",
8250 };
8251
8252 BOOL wine_vk_device_extension_supported(const char *name)
8253 {
8254     unsigned int i;
8255     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
8256     {
8257         if (strcmp(vk_device_extensions[i], name) == 0)
8258             return TRUE;
8259     }
8260     return FALSE;
8261 }
8262
8263 BOOL wine_vk_instance_extension_supported(const char *name)
8264 {
8265     unsigned int i;
8266     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
8267     {
8268         if (strcmp(vk_instance_extensions[i], name) == 0)
8269             return TRUE;
8270     }
8271     return FALSE;
8272 }
8273
8274 BOOL wine_vk_is_type_wrapped(VkObjectType type)
8275 {
8276     return FALSE ||
8277         type == VK_OBJECT_TYPE_COMMAND_BUFFER ||
8278         type == VK_OBJECT_TYPE_COMMAND_POOL ||
8279         type == VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT ||
8280         type == VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT ||
8281         type == VK_OBJECT_TYPE_DEVICE ||
8282         type == VK_OBJECT_TYPE_INSTANCE ||
8283         type == VK_OBJECT_TYPE_PHYSICAL_DEVICE ||
8284         type == VK_OBJECT_TYPE_QUEUE ||
8285         type == VK_OBJECT_TYPE_SURFACE_KHR;
8286 }
8287
8288 uint64_t wine_vk_unwrap_handle(VkObjectType type, uint64_t handle)
8289 {
8290     switch(type)
8291     {
8292     case VK_OBJECT_TYPE_COMMAND_BUFFER:
8293         return (uint64_t) (uintptr_t) ((VkCommandBuffer) (uintptr_t) handle)->command_buffer;
8294     case VK_OBJECT_TYPE_COMMAND_POOL:
8295         return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
8296     case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
8297         return (uint64_t) wine_debug_report_callback_from_handle(handle)->debug_callback;
8298     case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
8299         return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
8300     case VK_OBJECT_TYPE_DEVICE:
8301         return (uint64_t) (uintptr_t) ((VkDevice) (uintptr_t) handle)->device;
8302     case VK_OBJECT_TYPE_INSTANCE:
8303         return (uint64_t) (uintptr_t) ((VkInstance) (uintptr_t) handle)->instance;
8304     case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
8305         return (uint64_t) (uintptr_t) ((VkPhysicalDevice) (uintptr_t) handle)->phys_dev;
8306     case VK_OBJECT_TYPE_QUEUE:
8307         return (uint64_t) (uintptr_t) ((VkQueue) (uintptr_t) handle)->queue;
8308     case VK_OBJECT_TYPE_SURFACE_KHR:
8309         return (uint64_t) wine_surface_from_handle(handle)->surface;
8310     default:
8311        return handle;
8312     }
8313 }
8314
8315 const struct unix_funcs loader_funcs =
8316 {
8317     &wine_vkAcquireNextImage2KHR,
8318     &wine_vkAcquireNextImageKHR,
8319     &wine_vkAcquirePerformanceConfigurationINTEL,
8320     &wine_vkAcquireProfilingLockKHR,
8321     &wine_vkAllocateCommandBuffers,
8322     &wine_vkAllocateDescriptorSets,
8323     &wine_vkAllocateMemory,
8324     &wine_vkBeginCommandBuffer,
8325     &wine_vkBindAccelerationStructureMemoryNV,
8326     &wine_vkBindBufferMemory,
8327     &wine_vkBindBufferMemory2,
8328     &wine_vkBindBufferMemory2KHR,
8329     &wine_vkBindImageMemory,
8330     &wine_vkBindImageMemory2,
8331     &wine_vkBindImageMemory2KHR,
8332     &wine_vkBuildAccelerationStructuresKHR,
8333     &wine_vkCmdBeginConditionalRenderingEXT,
8334     &wine_vkCmdBeginDebugUtilsLabelEXT,
8335     &wine_vkCmdBeginQuery,
8336     &wine_vkCmdBeginQueryIndexedEXT,
8337     &wine_vkCmdBeginRenderPass,
8338     &wine_vkCmdBeginRenderPass2,
8339     &wine_vkCmdBeginRenderPass2KHR,
8340     &wine_vkCmdBeginTransformFeedbackEXT,
8341     &wine_vkCmdBindDescriptorSets,
8342     &wine_vkCmdBindIndexBuffer,
8343     &wine_vkCmdBindInvocationMaskHUAWEI,
8344     &wine_vkCmdBindPipeline,
8345     &wine_vkCmdBindPipelineShaderGroupNV,
8346     &wine_vkCmdBindShadingRateImageNV,
8347     &wine_vkCmdBindTransformFeedbackBuffersEXT,
8348     &wine_vkCmdBindVertexBuffers,
8349     &wine_vkCmdBindVertexBuffers2EXT,
8350     &wine_vkCmdBlitImage,
8351     &wine_vkCmdBlitImage2KHR,
8352     &wine_vkCmdBuildAccelerationStructureNV,
8353     &wine_vkCmdBuildAccelerationStructuresIndirectKHR,
8354     &wine_vkCmdBuildAccelerationStructuresKHR,
8355     &wine_vkCmdClearAttachments,
8356     &wine_vkCmdClearColorImage,
8357     &wine_vkCmdClearDepthStencilImage,
8358     &wine_vkCmdCopyAccelerationStructureKHR,
8359     &wine_vkCmdCopyAccelerationStructureNV,
8360     &wine_vkCmdCopyAccelerationStructureToMemoryKHR,
8361     &wine_vkCmdCopyBuffer,
8362     &wine_vkCmdCopyBuffer2KHR,
8363     &wine_vkCmdCopyBufferToImage,
8364     &wine_vkCmdCopyBufferToImage2KHR,
8365     &wine_vkCmdCopyImage,
8366     &wine_vkCmdCopyImage2KHR,
8367     &wine_vkCmdCopyImageToBuffer,
8368     &wine_vkCmdCopyImageToBuffer2KHR,
8369     &wine_vkCmdCopyMemoryToAccelerationStructureKHR,
8370     &wine_vkCmdCopyQueryPoolResults,
8371     &wine_vkCmdCuLaunchKernelNVX,
8372     &wine_vkCmdDebugMarkerBeginEXT,
8373     &wine_vkCmdDebugMarkerEndEXT,
8374     &wine_vkCmdDebugMarkerInsertEXT,
8375     &wine_vkCmdDispatch,
8376     &wine_vkCmdDispatchBase,
8377     &wine_vkCmdDispatchBaseKHR,
8378     &wine_vkCmdDispatchIndirect,
8379     &wine_vkCmdDraw,
8380     &wine_vkCmdDrawIndexed,
8381     &wine_vkCmdDrawIndexedIndirect,
8382     &wine_vkCmdDrawIndexedIndirectCount,
8383     &wine_vkCmdDrawIndexedIndirectCountAMD,
8384     &wine_vkCmdDrawIndexedIndirectCountKHR,
8385     &wine_vkCmdDrawIndirect,
8386     &wine_vkCmdDrawIndirectByteCountEXT,
8387     &wine_vkCmdDrawIndirectCount,
8388     &wine_vkCmdDrawIndirectCountAMD,
8389     &wine_vkCmdDrawIndirectCountKHR,
8390     &wine_vkCmdDrawMeshTasksIndirectCountNV,
8391     &wine_vkCmdDrawMeshTasksIndirectNV,
8392     &wine_vkCmdDrawMeshTasksNV,
8393     &wine_vkCmdDrawMultiEXT,
8394     &wine_vkCmdDrawMultiIndexedEXT,
8395     &wine_vkCmdEndConditionalRenderingEXT,
8396     &wine_vkCmdEndDebugUtilsLabelEXT,
8397     &wine_vkCmdEndQuery,
8398     &wine_vkCmdEndQueryIndexedEXT,
8399     &wine_vkCmdEndRenderPass,
8400     &wine_vkCmdEndRenderPass2,
8401     &wine_vkCmdEndRenderPass2KHR,
8402     &wine_vkCmdEndTransformFeedbackEXT,
8403     &wine_vkCmdExecuteCommands,
8404     &wine_vkCmdExecuteGeneratedCommandsNV,
8405     &wine_vkCmdFillBuffer,
8406     &wine_vkCmdInsertDebugUtilsLabelEXT,
8407     &wine_vkCmdNextSubpass,
8408     &wine_vkCmdNextSubpass2,
8409     &wine_vkCmdNextSubpass2KHR,
8410     &wine_vkCmdPipelineBarrier,
8411     &wine_vkCmdPipelineBarrier2KHR,
8412     &wine_vkCmdPreprocessGeneratedCommandsNV,
8413     &wine_vkCmdPushConstants,
8414     &wine_vkCmdPushDescriptorSetKHR,
8415     &wine_vkCmdPushDescriptorSetWithTemplateKHR,
8416     &wine_vkCmdResetEvent,
8417     &wine_vkCmdResetEvent2KHR,
8418     &wine_vkCmdResetQueryPool,
8419     &wine_vkCmdResolveImage,
8420     &wine_vkCmdResolveImage2KHR,
8421     &wine_vkCmdSetBlendConstants,
8422     &wine_vkCmdSetCheckpointNV,
8423     &wine_vkCmdSetCoarseSampleOrderNV,
8424     &wine_vkCmdSetColorWriteEnableEXT,
8425     &wine_vkCmdSetCullModeEXT,
8426     &wine_vkCmdSetDepthBias,
8427     &wine_vkCmdSetDepthBiasEnableEXT,
8428     &wine_vkCmdSetDepthBounds,
8429     &wine_vkCmdSetDepthBoundsTestEnableEXT,
8430     &wine_vkCmdSetDepthCompareOpEXT,
8431     &wine_vkCmdSetDepthTestEnableEXT,
8432     &wine_vkCmdSetDepthWriteEnableEXT,
8433     &wine_vkCmdSetDeviceMask,
8434     &wine_vkCmdSetDeviceMaskKHR,
8435     &wine_vkCmdSetDiscardRectangleEXT,
8436     &wine_vkCmdSetEvent,
8437     &wine_vkCmdSetEvent2KHR,
8438     &wine_vkCmdSetExclusiveScissorNV,
8439     &wine_vkCmdSetFragmentShadingRateEnumNV,
8440     &wine_vkCmdSetFragmentShadingRateKHR,
8441     &wine_vkCmdSetFrontFaceEXT,
8442     &wine_vkCmdSetLineStippleEXT,
8443     &wine_vkCmdSetLineWidth,
8444     &wine_vkCmdSetLogicOpEXT,
8445     &wine_vkCmdSetPatchControlPointsEXT,
8446     &wine_vkCmdSetPerformanceMarkerINTEL,
8447     &wine_vkCmdSetPerformanceOverrideINTEL,
8448     &wine_vkCmdSetPerformanceStreamMarkerINTEL,
8449     &wine_vkCmdSetPrimitiveRestartEnableEXT,
8450     &wine_vkCmdSetPrimitiveTopologyEXT,
8451     &wine_vkCmdSetRasterizerDiscardEnableEXT,
8452     &wine_vkCmdSetRayTracingPipelineStackSizeKHR,
8453     &wine_vkCmdSetSampleLocationsEXT,
8454     &wine_vkCmdSetScissor,
8455     &wine_vkCmdSetScissorWithCountEXT,
8456     &wine_vkCmdSetStencilCompareMask,
8457     &wine_vkCmdSetStencilOpEXT,
8458     &wine_vkCmdSetStencilReference,
8459     &wine_vkCmdSetStencilTestEnableEXT,
8460     &wine_vkCmdSetStencilWriteMask,
8461     &wine_vkCmdSetVertexInputEXT,
8462     &wine_vkCmdSetViewport,
8463     &wine_vkCmdSetViewportShadingRatePaletteNV,
8464     &wine_vkCmdSetViewportWScalingNV,
8465     &wine_vkCmdSetViewportWithCountEXT,
8466     &wine_vkCmdSubpassShadingHUAWEI,
8467     &wine_vkCmdTraceRaysIndirectKHR,
8468     &wine_vkCmdTraceRaysKHR,
8469     &wine_vkCmdTraceRaysNV,
8470     &wine_vkCmdUpdateBuffer,
8471     &wine_vkCmdWaitEvents,
8472     &wine_vkCmdWaitEvents2KHR,
8473     &wine_vkCmdWriteAccelerationStructuresPropertiesKHR,
8474     &wine_vkCmdWriteAccelerationStructuresPropertiesNV,
8475     &wine_vkCmdWriteBufferMarker2AMD,
8476     &wine_vkCmdWriteBufferMarkerAMD,
8477     &wine_vkCmdWriteTimestamp,
8478     &wine_vkCmdWriteTimestamp2KHR,
8479     &wine_vkCompileDeferredNV,
8480     &wine_vkCopyAccelerationStructureKHR,
8481     &wine_vkCopyAccelerationStructureToMemoryKHR,
8482     &wine_vkCopyMemoryToAccelerationStructureKHR,
8483     &wine_vkCreateAccelerationStructureKHR,
8484     &wine_vkCreateAccelerationStructureNV,
8485     &wine_vkCreateBuffer,
8486     &wine_vkCreateBufferView,
8487     &wine_vkCreateCommandPool,
8488     &wine_vkCreateComputePipelines,
8489     &wine_vkCreateCuFunctionNVX,
8490     &wine_vkCreateCuModuleNVX,
8491     &wine_vkCreateDebugReportCallbackEXT,
8492     &wine_vkCreateDebugUtilsMessengerEXT,
8493     &wine_vkCreateDeferredOperationKHR,
8494     &wine_vkCreateDescriptorPool,
8495     &wine_vkCreateDescriptorSetLayout,
8496     &wine_vkCreateDescriptorUpdateTemplate,
8497     &wine_vkCreateDescriptorUpdateTemplateKHR,
8498     &wine_vkCreateDevice,
8499     &wine_vkCreateEvent,
8500     &wine_vkCreateFence,
8501     &wine_vkCreateFramebuffer,
8502     &wine_vkCreateGraphicsPipelines,
8503     &wine_vkCreateImage,
8504     &wine_vkCreateImageView,
8505     &wine_vkCreateIndirectCommandsLayoutNV,
8506     &wine_vkCreateInstance,
8507     &wine_vkCreatePipelineCache,
8508     &wine_vkCreatePipelineLayout,
8509     &wine_vkCreatePrivateDataSlotEXT,
8510     &wine_vkCreateQueryPool,
8511     &wine_vkCreateRayTracingPipelinesKHR,
8512     &wine_vkCreateRayTracingPipelinesNV,
8513     &wine_vkCreateRenderPass,
8514     &wine_vkCreateRenderPass2,
8515     &wine_vkCreateRenderPass2KHR,
8516     &wine_vkCreateSampler,
8517     &wine_vkCreateSamplerYcbcrConversion,
8518     &wine_vkCreateSamplerYcbcrConversionKHR,
8519     &wine_vkCreateSemaphore,
8520     &wine_vkCreateShaderModule,
8521     &wine_vkCreateSwapchainKHR,
8522     &wine_vkCreateValidationCacheEXT,
8523     &wine_vkCreateWin32SurfaceKHR,
8524     &wine_vkDebugMarkerSetObjectNameEXT,
8525     &wine_vkDebugMarkerSetObjectTagEXT,
8526     &wine_vkDebugReportMessageEXT,
8527     &wine_vkDeferredOperationJoinKHR,
8528     &wine_vkDestroyAccelerationStructureKHR,
8529     &wine_vkDestroyAccelerationStructureNV,
8530     &wine_vkDestroyBuffer,
8531     &wine_vkDestroyBufferView,
8532     &wine_vkDestroyCommandPool,
8533     &wine_vkDestroyCuFunctionNVX,
8534     &wine_vkDestroyCuModuleNVX,
8535     &wine_vkDestroyDebugReportCallbackEXT,
8536     &wine_vkDestroyDebugUtilsMessengerEXT,
8537     &wine_vkDestroyDeferredOperationKHR,
8538     &wine_vkDestroyDescriptorPool,
8539     &wine_vkDestroyDescriptorSetLayout,
8540     &wine_vkDestroyDescriptorUpdateTemplate,
8541     &wine_vkDestroyDescriptorUpdateTemplateKHR,
8542     &wine_vkDestroyDevice,
8543     &wine_vkDestroyEvent,
8544     &wine_vkDestroyFence,
8545     &wine_vkDestroyFramebuffer,
8546     &wine_vkDestroyImage,
8547     &wine_vkDestroyImageView,
8548     &wine_vkDestroyIndirectCommandsLayoutNV,
8549     &wine_vkDestroyInstance,
8550     &wine_vkDestroyPipeline,
8551     &wine_vkDestroyPipelineCache,
8552     &wine_vkDestroyPipelineLayout,
8553     &wine_vkDestroyPrivateDataSlotEXT,
8554     &wine_vkDestroyQueryPool,
8555     &wine_vkDestroyRenderPass,
8556     &wine_vkDestroySampler,
8557     &wine_vkDestroySamplerYcbcrConversion,
8558     &wine_vkDestroySamplerYcbcrConversionKHR,
8559     &wine_vkDestroySemaphore,
8560     &wine_vkDestroyShaderModule,
8561     &wine_vkDestroySurfaceKHR,
8562     &wine_vkDestroySwapchainKHR,
8563     &wine_vkDestroyValidationCacheEXT,
8564     &wine_vkDeviceWaitIdle,
8565     &wine_vkEndCommandBuffer,
8566     &wine_vkEnumerateDeviceExtensionProperties,
8567     &wine_vkEnumerateDeviceLayerProperties,
8568     &wine_vkEnumerateInstanceExtensionProperties,
8569     &wine_vkEnumerateInstanceVersion,
8570     &wine_vkEnumeratePhysicalDeviceGroups,
8571     &wine_vkEnumeratePhysicalDeviceGroupsKHR,
8572     &wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
8573     &wine_vkEnumeratePhysicalDevices,
8574     &wine_vkFlushMappedMemoryRanges,
8575     &wine_vkFreeCommandBuffers,
8576     &wine_vkFreeDescriptorSets,
8577     &wine_vkFreeMemory,
8578     &wine_vkGetAccelerationStructureBuildSizesKHR,
8579     &wine_vkGetAccelerationStructureDeviceAddressKHR,
8580     &wine_vkGetAccelerationStructureHandleNV,
8581     &wine_vkGetAccelerationStructureMemoryRequirementsNV,
8582     &wine_vkGetBufferDeviceAddress,
8583     &wine_vkGetBufferDeviceAddressEXT,
8584     &wine_vkGetBufferDeviceAddressKHR,
8585     &wine_vkGetBufferMemoryRequirements,
8586     &wine_vkGetBufferMemoryRequirements2,
8587     &wine_vkGetBufferMemoryRequirements2KHR,
8588     &wine_vkGetBufferOpaqueCaptureAddress,
8589     &wine_vkGetBufferOpaqueCaptureAddressKHR,
8590     &wine_vkGetCalibratedTimestampsEXT,
8591     &wine_vkGetDeferredOperationMaxConcurrencyKHR,
8592     &wine_vkGetDeferredOperationResultKHR,
8593     &wine_vkGetDescriptorSetLayoutSupport,
8594     &wine_vkGetDescriptorSetLayoutSupportKHR,
8595     &wine_vkGetDeviceAccelerationStructureCompatibilityKHR,
8596     &wine_vkGetDeviceGroupPeerMemoryFeatures,
8597     &wine_vkGetDeviceGroupPeerMemoryFeaturesKHR,
8598     &wine_vkGetDeviceGroupPresentCapabilitiesKHR,
8599     &wine_vkGetDeviceGroupSurfacePresentModesKHR,
8600     &wine_vkGetDeviceMemoryCommitment,
8601     &wine_vkGetDeviceMemoryOpaqueCaptureAddress,
8602     &wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
8603     &wine_vkGetDeviceQueue,
8604     &wine_vkGetDeviceQueue2,
8605     &wine_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
8606     &wine_vkGetEventStatus,
8607     &wine_vkGetFenceStatus,
8608     &wine_vkGetGeneratedCommandsMemoryRequirementsNV,
8609     &wine_vkGetImageMemoryRequirements,
8610     &wine_vkGetImageMemoryRequirements2,
8611     &wine_vkGetImageMemoryRequirements2KHR,
8612     &wine_vkGetImageSparseMemoryRequirements,
8613     &wine_vkGetImageSparseMemoryRequirements2,
8614     &wine_vkGetImageSparseMemoryRequirements2KHR,
8615     &wine_vkGetImageSubresourceLayout,
8616     &wine_vkGetImageViewAddressNVX,
8617     &wine_vkGetImageViewHandleNVX,
8618     &wine_vkGetMemoryHostPointerPropertiesEXT,
8619     &wine_vkGetPerformanceParameterINTEL,
8620     &wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
8621     &wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
8622     &wine_vkGetPhysicalDeviceExternalBufferProperties,
8623     &wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
8624     &wine_vkGetPhysicalDeviceExternalFenceProperties,
8625     &wine_vkGetPhysicalDeviceExternalFencePropertiesKHR,
8626     &wine_vkGetPhysicalDeviceExternalSemaphoreProperties,
8627     &wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
8628     &wine_vkGetPhysicalDeviceFeatures,
8629     &wine_vkGetPhysicalDeviceFeatures2,
8630     &wine_vkGetPhysicalDeviceFeatures2KHR,
8631     &wine_vkGetPhysicalDeviceFormatProperties,
8632     &wine_vkGetPhysicalDeviceFormatProperties2,
8633     &wine_vkGetPhysicalDeviceFormatProperties2KHR,
8634     &wine_vkGetPhysicalDeviceFragmentShadingRatesKHR,
8635     &wine_vkGetPhysicalDeviceImageFormatProperties,
8636     &wine_vkGetPhysicalDeviceImageFormatProperties2,
8637     &wine_vkGetPhysicalDeviceImageFormatProperties2KHR,
8638     &wine_vkGetPhysicalDeviceMemoryProperties,
8639     &wine_vkGetPhysicalDeviceMemoryProperties2,
8640     &wine_vkGetPhysicalDeviceMemoryProperties2KHR,
8641     &wine_vkGetPhysicalDeviceMultisamplePropertiesEXT,
8642     &wine_vkGetPhysicalDevicePresentRectanglesKHR,
8643     &wine_vkGetPhysicalDeviceProperties,
8644     &wine_vkGetPhysicalDeviceProperties2,
8645     &wine_vkGetPhysicalDeviceProperties2KHR,
8646     &wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
8647     &wine_vkGetPhysicalDeviceQueueFamilyProperties,
8648     &wine_vkGetPhysicalDeviceQueueFamilyProperties2,
8649     &wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
8650     &wine_vkGetPhysicalDeviceSparseImageFormatProperties,
8651     &wine_vkGetPhysicalDeviceSparseImageFormatProperties2,
8652     &wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
8653     &wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
8654     &wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
8655     &wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
8656     &wine_vkGetPhysicalDeviceSurfaceFormats2KHR,
8657     &wine_vkGetPhysicalDeviceSurfaceFormatsKHR,
8658     &wine_vkGetPhysicalDeviceSurfacePresentModesKHR,
8659     &wine_vkGetPhysicalDeviceSurfaceSupportKHR,
8660     &wine_vkGetPhysicalDeviceToolPropertiesEXT,
8661     &wine_vkGetPhysicalDeviceWin32PresentationSupportKHR,
8662     &wine_vkGetPipelineCacheData,
8663     &wine_vkGetPipelineExecutableInternalRepresentationsKHR,
8664     &wine_vkGetPipelineExecutablePropertiesKHR,
8665     &wine_vkGetPipelineExecutableStatisticsKHR,
8666     &wine_vkGetPrivateDataEXT,
8667     &wine_vkGetQueryPoolResults,
8668     &wine_vkGetQueueCheckpointData2NV,
8669     &wine_vkGetQueueCheckpointDataNV,
8670     &wine_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
8671     &wine_vkGetRayTracingShaderGroupHandlesKHR,
8672     &wine_vkGetRayTracingShaderGroupHandlesNV,
8673     &wine_vkGetRayTracingShaderGroupStackSizeKHR,
8674     &wine_vkGetRenderAreaGranularity,
8675     &wine_vkGetSemaphoreCounterValue,
8676     &wine_vkGetSemaphoreCounterValueKHR,
8677     &wine_vkGetShaderInfoAMD,
8678     &wine_vkGetSwapchainImagesKHR,
8679     &wine_vkGetValidationCacheDataEXT,
8680     &wine_vkInitializePerformanceApiINTEL,
8681     &wine_vkInvalidateMappedMemoryRanges,
8682     &wine_vkMapMemory,
8683     &wine_vkMergePipelineCaches,
8684     &wine_vkMergeValidationCachesEXT,
8685     &wine_vkQueueBeginDebugUtilsLabelEXT,
8686     &wine_vkQueueBindSparse,
8687     &wine_vkQueueEndDebugUtilsLabelEXT,
8688     &wine_vkQueueInsertDebugUtilsLabelEXT,
8689     &wine_vkQueuePresentKHR,
8690     &wine_vkQueueSetPerformanceConfigurationINTEL,
8691     &wine_vkQueueSubmit,
8692     &wine_vkQueueSubmit2KHR,
8693     &wine_vkQueueWaitIdle,
8694     &wine_vkReleasePerformanceConfigurationINTEL,
8695     &wine_vkReleaseProfilingLockKHR,
8696     &wine_vkResetCommandBuffer,
8697     &wine_vkResetCommandPool,
8698     &wine_vkResetDescriptorPool,
8699     &wine_vkResetEvent,
8700     &wine_vkResetFences,
8701     &wine_vkResetQueryPool,
8702     &wine_vkResetQueryPoolEXT,
8703     &wine_vkSetDebugUtilsObjectNameEXT,
8704     &wine_vkSetDebugUtilsObjectTagEXT,
8705     &wine_vkSetEvent,
8706     &wine_vkSetPrivateDataEXT,
8707     &wine_vkSignalSemaphore,
8708     &wine_vkSignalSemaphoreKHR,
8709     &wine_vkSubmitDebugUtilsMessageEXT,
8710     &wine_vkTrimCommandPool,
8711     &wine_vkTrimCommandPoolKHR,
8712     &wine_vkUninitializePerformanceApiINTEL,
8713     &wine_vkUnmapMemory,
8714     &wine_vkUpdateDescriptorSetWithTemplate,
8715     &wine_vkUpdateDescriptorSetWithTemplateKHR,
8716     &wine_vkUpdateDescriptorSets,
8717     &wine_vkWaitForFences,
8718     &wine_vkWaitForPresentKHR,
8719     &wine_vkWaitSemaphores,
8720     &wine_vkWaitSemaphoresKHR,
8721     &wine_vkWriteAccelerationStructuresPropertiesKHR,
8722 };