Repository navigation
Expand file tree
/
Copy pathvk.c
More file actions
895 lines (892 loc) · 70.5 KB
/
Copy pathvk.c
File metadata and controls
895 lines (892 loc) · 70.5 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
#include "vk.h"
PFN_vkVoidFunction domVkGetDeviceProcAddr(PFN_vkGetDeviceProcAddr fp, VkDevice device, const char* pName) {
return (*fp)(device, pName);
}
VkResult domVkAllocateCommandBuffers(PFN_vkAllocateCommandBuffers fp, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
return (*fp)(device, pAllocateInfo, pCommandBuffers);
}
VkResult domVkAllocateDescriptorSets(PFN_vkAllocateDescriptorSets fp, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
return (*fp)(device, pAllocateInfo, pDescriptorSets);
}
VkResult domVkAllocateMemory(PFN_vkAllocateMemory fp, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
return (*fp)(device, pAllocateInfo, pAllocator, pMemory);
}
VkResult domVkBeginCommandBuffer(PFN_vkBeginCommandBuffer fp, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
return (*fp)(commandBuffer, pBeginInfo);
}
VkResult domVkBindBufferMemory2(PFN_vkBindBufferMemory2 fp, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {
return (*fp)(device, bindInfoCount, pBindInfos);
}
VkResult domVkBindBufferMemory(PFN_vkBindBufferMemory fp, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
return (*fp)(device, buffer, memory, memoryOffset);
}
VkResult domVkBindImageMemory(PFN_vkBindImageMemory fp, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
return (*fp)(device, image, memory, memoryOffset);
}
VkResult domVkCreateBuffer(PFN_vkCreateBuffer fp, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
return (*fp)(device, pCreateInfo, pAllocator, pBuffer);
}
VkResult domVkCreateBufferView(PFN_vkCreateBufferView fp, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
return (*fp)(device, pCreateInfo, pAllocator, pView);
}
VkResult domVkCreateCommandPool(PFN_vkCreateCommandPool fp, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
return (*fp)(device, pCreateInfo, pAllocator, pCommandPool);
}
VkResult domVkCreateComputePipelines(PFN_vkCreateComputePipelines fp, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
return (*fp)(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
VkResult domVkCreateDescriptorPool(PFN_vkCreateDescriptorPool fp, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
return (*fp)(device, pCreateInfo, pAllocator, pDescriptorPool);
}
VkResult domVkCreateDescriptorSetLayout(PFN_vkCreateDescriptorSetLayout fp, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
return (*fp)(device, pCreateInfo, pAllocator, pSetLayout);
}
VkResult domVkCreateDevice(PFN_vkCreateDevice fp, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
return (*fp)(physicalDevice, pCreateInfo, pAllocator, pDevice);
}
VkResult domVkCreateEvent(PFN_vkCreateEvent fp, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
return (*fp)(device, pCreateInfo, pAllocator, pEvent);
}
VkResult domVkCreateFence(PFN_vkCreateFence fp, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
return (*fp)(device, pCreateInfo, pAllocator, pFence);
}
VkResult domVkCreateFramebuffer(PFN_vkCreateFramebuffer fp, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
return (*fp)(device, pCreateInfo, pAllocator, pFramebuffer);
}
VkResult domVkCreateGraphicsPipelines(PFN_vkCreateGraphicsPipelines fp, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
return (*fp)(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
VkResult domVkCreateImage(PFN_vkCreateImage fp, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
return (*fp)(device, pCreateInfo, pAllocator, pImage);
}
VkResult domVkCreateImageView(PFN_vkCreateImageView fp, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
return (*fp)(device, pCreateInfo, pAllocator, pView);
}
VkResult domVkCreateInstance(PFN_vkCreateInstance fp, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
return (*fp)(pCreateInfo, pAllocator, pInstance);
}
VkResult domVkCreatePipelineCache(PFN_vkCreatePipelineCache fp, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
return (*fp)(device, pCreateInfo, pAllocator, pPipelineCache);
}
VkResult domVkCreatePipelineLayout(PFN_vkCreatePipelineLayout fp, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
return (*fp)(device, pCreateInfo, pAllocator, pPipelineLayout);
}
VkResult domVkCreateQueryPool(PFN_vkCreateQueryPool fp, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
return (*fp)(device, pCreateInfo, pAllocator, pQueryPool);
}
VkResult domVkCreateRenderPass(PFN_vkCreateRenderPass fp, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
return (*fp)(device, pCreateInfo, pAllocator, pRenderPass);
}
VkResult domVkCreateSampler(PFN_vkCreateSampler fp, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
return (*fp)(device, pCreateInfo, pAllocator, pSampler);
}
VkResult domVkCreateSemaphore(PFN_vkCreateSemaphore fp, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
return (*fp)(device, pCreateInfo, pAllocator, pSemaphore);
}
VkResult domVkCreateShaderModule(PFN_vkCreateShaderModule fp, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
return (*fp)(device, pCreateInfo, pAllocator, pShaderModule);
}
VkResult domVkDeviceWaitIdle(PFN_vkDeviceWaitIdle fp, VkDevice device) {
return (*fp)(device);
}
VkResult domVkEndCommandBuffer(PFN_vkEndCommandBuffer fp, VkCommandBuffer commandBuffer) {
return (*fp)(commandBuffer);
}
VkResult domVkEnumerateDeviceExtensionProperties(PFN_vkEnumerateDeviceExtensionProperties fp, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
return (*fp)(physicalDevice, pLayerName, pPropertyCount, pProperties);
}
VkResult domVkEnumerateDeviceLayerProperties(PFN_vkEnumerateDeviceLayerProperties fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
return (*fp)(physicalDevice, pPropertyCount, pProperties);
}
VkResult domVkEnumerateInstanceExtensionProperties(PFN_vkEnumerateInstanceExtensionProperties fp, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
return (*fp)(pLayerName, pPropertyCount, pProperties);
}
VkResult domVkEnumerateInstanceLayerProperties(PFN_vkEnumerateInstanceLayerProperties fp, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
return (*fp)(pPropertyCount, pProperties);
}
VkResult domVkEnumeratePhysicalDevices(PFN_
10000
vkEnumeratePhysicalDevices fp, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
return (*fp)(instance, pPhysicalDeviceCount, pPhysicalDevices);
}
VkResult domVkFlushMappedMemoryRanges(PFN_vkFlushMappedMemoryRanges fp, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
return (*fp)(device, memoryRangeCount, pMemoryRanges);
}
VkResult domVkFreeDescriptorSets(PFN_vkFreeDescriptorSets fp, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
return (*fp)(device, descriptorPool, descriptorSetCount, pDescriptorSets);
}
VkResult domVkGetEventStatus(PFN_vkGetEventStatus fp, VkDevice device, VkEvent event) {
return (*fp)(device, event);
}
VkResult domVkGetFenceStatus(PFN_vkGetFenceStatus fp, VkDevice device, VkFence fence) {
return (*fp)(device, fence);
}
VkResult domVkGetPhysicalDeviceImageFormatProperties(PFN_vkGetPhysicalDeviceImageFormatProperties fp, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
return (*fp)(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
}
VkResult domVkGetPipelineCacheData(PFN_vkGetPipelineCacheData fp, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
return (*fp)(device, pipelineCache,pDataSize, pData);
}
VkResult domVkGetQueryPoolResults(PFN_vkGetQueryPoolResults fp, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
return (*fp)(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
}
VkResult domVkInvalidateMappedMemoryRanges(PFN_vkInvalidateMappedMemoryRanges fp, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
return (*fp)(device, memoryRangeCount, pMemoryRanges);
}
VkResult domVkMapMemory(PFN_vkMapMemory fp, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
return (*fp)(device, memory, offset, size, flags, ppData);
}
VkResult domVkMergePipelineCaches(PFN_vkMergePipelineCaches fp, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
return (*fp)(device, dstCache, srcCacheCount, pSrcCaches);
}
VkResult domVkQueueBindSparse(PFN_vkQueueBindSparse fp, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
return (*fp)(queue, bindInfoCount, pBindInfo, fence);
}
VkResult domVkQueueSubmit(PFN_vkQueueSubmit fp, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
return (*fp)(queue, submitCount, pSubmits, fence);
}
VkResult domVkQueueWaitIdle(PFN_vkQueueWaitIdle fp, VkQueue queue) {
return (*fp)(queue);
}
VkResult domVkResetCommandBuffer(PFN_vkResetCommandBuffer fp, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
return (*fp)(commandBuffer, flags);
}
VkResult domVkResetCommandPool(PFN_vkResetCommandPool fp, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
return (*fp)(device, commandPool, flags);
}
VkResult domVkResetDescriptorPool(PFN_vkResetDescriptorPool fp, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
return (*fp)(device, descriptorPool, flags);
}
VkResult domVkResetEvent(PFN_vkResetEvent fp, VkDevice device, VkEvent event) {
return (*fp)(device, event);
}
VkResult domVkResetFences(PFN_vkResetFences fp, VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
return (*fp)(device, fenceCount, pFences);
}
VkResult domVkSetEvent(PFN_vkSetEvent fp, VkDevice device, VkEvent event) {
return (*fp)(device, event);
}
VkResult domVkWaitForFences(PFN_vkWaitForFences fp, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
return (*fp)(device, fenceCount, pFences, waitAll, timeout);
}
void domVkCmdBeginQuery(PFN_vkCmdBeginQuery fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
(*fp)(commandBuffer, queryPool, query, flags);
}
void domVkCmdBeginRenderPass(PFN_vkCmdBeginRenderPass fp, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
(*fp)(commandBuffer, pRenderPassBegin, contents);
}
void domVkCmdBindDescriptorSets(PFN_vkCmdBindDescriptorSets fp, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
(*fp)(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
void domVkCmdBindIndexBuffer(PFN_vkCmdBindIndexBuffer fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
(*fp)(commandBuffer, buffer, offset, indexType);
}
void domVkCmdBindPipeline(PFN_vkCmdBindPipeline fp, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
(*fp)(commandBuffer, pipelineBindPoint, pipeline);
}
void domVkCmdBindVertexBuffers(PFN_vkCmdBindVertexBuffers fp, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
(*fp)(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
}
void domVkCmdBlitImage(PFN_vkCmdBlitImage fp, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
(*fp)(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
void domVkCmdClearAttachments(PFN_vkCmdClearAttachments fp, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
(*fp)(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
void domVkCmdClearColorImage(PFN_vkCmdClearColorImage fp, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
(*fp)(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
void domVkCmdClearDepthStencilImage(PFN_vkCmdClearDepthStencilImage fp, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
(*fp)(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
void domVkCmdCopyBuffer(PFN_vkCmdCopyBuffer fp, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
(*fp)(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
void domVkCmdCopyBufferToImage(PFN_vkCmdCopyBufferToImage fp, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
(*fp)(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
void domVkCmdCopyImage(PFN_vkCmdCopyImage fp, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
(*fp)(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
void domVkCmdCopyImageToBuffer(PFN_vkCmdCopyImageToBuffer fp, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
(*fp)(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
void domVkCmdCopyQueryPoolResults(PFN_vkCmdCopyQueryPoolResults fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
(*fp)(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
void domVkCmdDispatchIndirect(PFN_vkCmdDispatchIndirect fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
(*fp)(commandBuffer, buffer, offset);
}
void domVkCmdDispatch(PFN_vkCmdDispatch fp, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
(*fp)(commandBuffer, groupCountX, groupCountY, groupCountZ);
}
void domVkCmdDrawIndexedIndirect(PFN_vkCmdDrawIndexedIndirect fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
(*fp)(commandBuffer, buffer, offset, drawCount, stride);
}
void domVkCmdDrawIndexed(PFN_vkCmdDrawIndexed fp, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
(*fp)(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
void domVkCmdDrawIndirect(PFN_vkCmdDrawIndirect fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
(*fp)(commandBuffer, buffer, offset, drawCount, stride);
}
void domVkCmdDraw(PFN_vkCmdDraw fp, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
(*fp)(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
void domVkCmdEndQuery(PFN_vkCmdEndQuery fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
(*fp)(commandBuffer, queryPool, query);
}
void domVkCmdEndRenderPass(PFN_vkCmdEndRenderPass fp, VkCommandBuffer commandBuffer) {
(*fp)(commandBuffer);
}
void domVkCmdExecuteCommands(PFN_vkCmdExecuteCommands fp, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
(*fp)(commandBuffer, commandBufferCount, pCommandBuffers);
}
void domVkCmdFillBuffer(PFN_vkCmdFillBuffer fp, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
(*fp)(commandBuffer, dstBuffer, dstOffset, size, data);
}
void domVkCmdNextSubpass(PFN_vkCmdNextSubpass fp, VkCommandBuffer commandBuffer, VkSubpassContents contents) {
(*fp)(commandBuffer, contents);
}
void domVkCmdPipelineBarrier(PFN_vkCmdPipelineBarrier fp, 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) {
(*fp)(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
void domVkCmdPushConstants(PFN_vkCmdPushConstants fp, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
(*fp)(commandBuffer, layout, stageFlags, offset, size, pValues);
}
void domVkCmdResetEvent(PFN_vkCmdResetEvent fp, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
(*fp)(commandBuffer, event, stageMask);
}
void domVkCmdResetQueryPool(PFN_vkCmdResetQueryPool fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
(*fp)(commandBuffer, queryPool, firstQuery, queryCount);
}
void domVkCmdResolveImage(PFN_vkCmdResolveImage fp, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
(*fp)(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
void domVkCmdSetBlendConstants(PFN_vkCmdSetBlendConstants fp, VkCommandBuffer commandBuffer, const float blendConstants[4]) {
(*fp)(commandBuffer, blendConstants);
}
void domVkCmdSetDepthBias(PFN_vkCmdSetDepthBias fp, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
(*fp)(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
void domVkCmdSetDepthBounds(PFN_vkCmdSetDepthBounds fp, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
(*fp)(commandBuffer, minDepthBounds, maxDepthBounds);
}
void domVkCmdSetDeviceMask(PFN_vkCmdSetDeviceMask fp, VkCommandBuffer commandBuffer, uint32_t deviceMask) {
(*fp)(commandBuffer, deviceMask);
}
void domVkCmdSetEvent(PFN_vkCmdSetEvent fp, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
(*fp)(commandBuffer, event, stageMask);
}
void domVkCmdSetLineWidth(PFN_vkCmdSetLineWidth fp, VkCommandBuffer commandBuffer, float lineWidth) {
(*fp)(commandBuffer, lineWidth);
}
void domVkCmdSetScissor(PFN_vkCmdSetScissor fp, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
(*fp)(commandBuffer, firstScissor, scissorCount, pScissors);
}
void domVkCmdSetStencilCompareMask(PFN_vkCmdSetStencilCompareMask fp, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
(*fp)(commandBuffer, faceMask, compareMask);
}
void domVkCmdSetStencilReference(PFN_vkCmdSetStencilReference fp, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
(*fp)(commandBuffer, faceMask, reference);
}
void domVkCmdSetStencilWriteMask(PFN_vkCmdSetStencilWriteMask fp, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
(*fp)(commandBuffer, faceMask, writeMask);
}
void domVkCmdSetViewport(PFN_vkCmdSetViewport fp, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
(*fp)(commandBuffer, firstViewport, viewportCount, pViewports);
}
void domVkCmdUpdateBuffer(PFN_vkCmdUpdateBuffer fp, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {
(*fp)(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
void domVkCmdWaitEvents(PFN_vkCmdWaitEvents fp, 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) {
(*fp)(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
void domVkCmdWriteTimestamp(PFN_vkCmdWriteTimestamp fp, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
(*fp)(commandBuffer, pipelineStage, queryPool, query);
}
void domVkDestroyBuffer(PFN_vkDestroyBuffer fp, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, buffer, pAllocator);
}
void domVkDestroyBufferView(PFN_vkDestroyBufferView fp, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, bufferView, pAllocator);
}
void domVkDestroyCommandPool(PFN_vkDestroyCommandPool fp, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, commandPool, pAllocator);
}
void domVkDestroyDescriptorPool(PFN_vkDestroyDescriptorPool fp, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, descriptorPool, pAllocator);
}
void domVkDestroyDescriptorSetLayout(PFN_vkDestroyDescriptorSetLayout fp, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, descriptorSetLayout, pAllocator);
}
void domVkDestroyDevice(PFN_vkDestroyDevice fp, VkDevice device, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, pAllocator);
}
void domVkDestroyEvent(PFN_vkDestroyEvent fp, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, event, pAllocator);
}
void domVkDestroyFence(PFN_vkDestroyFence fp, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, fence, pAllocator);
}
void domVkDestroyFramebuffer(PFN_vkDestroyFramebuffer fp, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, framebuffer, pAllocator);
}
void domVkDestroyImage(PFN_vkDestroyImage fp, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, image, pAllocator);
}
void domVkDestroyImageView(PFN_vkDestroyImageView fp, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, imageView, pAllocator);
}
void domVkDestroyInstance(PFN_vkDestroyInstance fp, VkInstance instance, const VkAllocationCallbacks* pAllocator) {
(*fp)(instance, pAllocator);
}
void domVkDestroyPipelineCache(PFN_vkDestroyPipelineCache fp, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, pipelineCache, pAllocator);
}
void domVkDestroyPipelineLayout(PFN_vkDestroyPipelineLayout fp, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, pipelineLayout, pAllocator);
}
void domVkDestroyPipeline(PFN_vkDestroyPipeline fp, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, pipeline, pAllocator);
}
void domVkDestroyQueryPool(PFN_vkDestroyQueryPool fp, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, queryPool, pAllocator);
}
void domVkDestroyRenderPass(PFN_vkDestroyRenderPass fp, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, renderPass, pAllocator);
}
void domVkDestroySampler(PFN_vkDestroySampler fp, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, sampler, pAllocator);
}
void domVkDestroySemaphore(PFN_vkDestroySemaphore fp, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, semaphore, pAllocator);
}
void domVkDestroyShaderModule(PFN_vkDestroyShaderModule fp, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, shaderModule, pAllocator);
}
void domVkFreeCommandBuffers(PFN_vkFreeCommandBuffers fp, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
(*fp)(device, commandPool, commandBufferCount, pCommandBuffers);
}
void domVkFreeMemory(PFN_vkFreeMemory fp, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, memory, pAllocator);
}
void domVkGetBufferMemoryRequirements(PFN_vkGetBufferMemoryRequirements fp, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
(*fp)(device, buffer, pMemoryRequirements);
}
void domVkGetDeviceMemoryCommitment(PFN_vkGetDeviceMemoryCommitment fp, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
(*fp)(device, memory, pCommittedMemoryInBytes);
}
void domVkGetDeviceQueue(PFN_vkGetDeviceQueue fp, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
(*fp)(device, queueFamilyIndex, queueIndex, pQueue);
}
void domVkGetDeviceQueue2(PFN_vkGetDeviceQueue2 fp, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {
(*fp)(device, pQueueInfo, pQueue);
}
void domVkGetImageMemoryRequirements(PFN_vkGetImageMemoryRequirements fp, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
(*fp)(device, image, pMemoryRequirements);
}
void domVkGetImageSparseMemoryRequirements(PFN_vkGetImageSparseMemoryRequirements fp, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
(*fp)(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
void domVkGetImageSubresourceLayout(PFN_vkGetImageSubresourceLayout fp, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
(*fp)(device, image, pSubresource, pLayout);
}
void domVkGetPhysicalDeviceFeatures(PFN_vkGetPhysicalDeviceFeatures fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
(*fp)(physicalDevice, pFeatures);
}
void domVkGetPhysicalDeviceFormatProperties(PFN_vkGetPhysicalDeviceFormatProperties fp, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
(*fp)(physicalDevice, format, pFormatProperties);
}
void domVkGetPhysicalDeviceMemoryProperties(PFN_vkGetPhysicalDeviceMemoryProperties fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
(*fp)(physicalDevice, pMemoryProperties);
}
void domVkGetPhysicalDeviceProperties2(PFN_vkGetPhysicalDeviceProperties2 fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {
(*fp)(physicalDevice, pProperties);
}
void domVkGetPhysicalDeviceProperties(PFN_vkGetPhysicalDeviceProperties fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
(*fp)(physicalDevice, pProperties);
}
void domVkGetPhysicalDeviceQueueFamilyProperties(PFN_vkGetPhysicalDeviceQueueFamilyProperties fp, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
(*fp)(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
void domVkGetPhysicalDeviceSparseImageFormatProperties(PFN_vkGetPhysicalDeviceSparseImageFormatProperties fp, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
(*fp)(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
}
void domVkGetRenderAreaGranularity(PFN_vkGetRenderAreaGranularity fp, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
(*fp)(device, renderPass, pGranularity);
}
void domVkTrimCommandPool(PFN_vkTrimCommandPool fp, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
(*fp)(device, commandPool, flags);
}
void domVkUnmapMemory(PFN_vkUnmapMemory fp, VkDevice device, VkDeviceMemory memory) {
(*fp)(device, memory);
}
void domVkUpdateDescriptorSets(PFN_vkUpdateDescriptorSets fp, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
(*fp)(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
}
VkBool32 domVkDebugReportCallbackEXT(PFN_vkDebugReportCallbackEXT fp, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData) {
return (*fp)(flags, objectType, object, location, messageCode, pLayerPrefix, pMessage, pUserData);
}
VkBool32 domVkDebugUtilsMessengerCallbackEXT(PFN_vkDebugUtilsMessengerCallbackEXT fp, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData) {
return (*fp)(messageSeverity, messageTypes, pCallbackData, pUserData);
}
VkResult domVkAcquireNextImage2KHR(PFN_vkAcquireNextImage2KHR fp, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) {
return (*fp)(device, pAcquireInfo, pImageIndex);
}
VkResult domVkAcquireNextImageKHR(PFN_vkAcquireNextImageKHR fp, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
return (*fp)(device, swapchain, timeout, semaphore, fence, pImageIndex);
}
VkResult domVkBindBufferMemory2KHR(PFN_vkBindBufferMemory2KHR fp, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {
return (*fp)(device, bindInfoCount, pBindInfos);
}
VkResult domVkBindImageMemory2KHR(PFN_vkBindImageMemory2KHR fp, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {
return (*fp)(device, bindInfoCount, pBindInfos);
}
VkResult domVkCreateDebugReportCallbackEXT(PFN_vkCreateDebugReportCallbackEXT fp, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) {
return (*fp)(instance, pCreateInfo, pAllocator, pCallback);
}
VkResult domVkCreateDebugUtilsMessengerEXT(PFN_vkCreateDebugUtilsMessengerEXT fp, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) {
return (*fp)(instance, pCreateInfo, pAllocator, pMessenger);
}
VkResult domVkCreateDescriptorUpdateTemplateKHR(PFN_vkCreateDescriptorUpdateTemplateKHR fp, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
return (*fp)(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
}
VkResult domVkCreateDisplayModeKHR(PFN_vkCreateDisplayModeKHR fp, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) {
return (*fp)(physicalDevice, display, pCreateInfo, pAllocator, pMode);
}
VkResult domVkCreateDisplayPlaneSurfaceKHR(PFN_vkCreateDisplayPlaneSurfaceKHR fp, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
return (*fp)(instance, pCreateInfo, pAllocator, pSurface);
}
VkResult domVkCreateRenderPass2KHR(PFN_vkCreateRenderPass2KHR fp, VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
return (*fp)(device, pCreateInfo, pAllocator, pRenderPass);
}
VkResult domVkCreateSamplerYcbcrConversionKHR(PFN_vkCreateSamplerYcbcrConversionKHR fp, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
return (*fp)(device, pCreateInfo, pAllocator, pYcbcrConversion);
}
VkResult domVkCreateSharedSwapchainsKHR(PFN_vkCreateSharedSwapchainsKHR fp, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {
return (*fp)(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
}
VkResult domVkCreateSwapchainKHR(PFN_vkCreateSwapchainKHR fp, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
return (*fp)(device, pCreateInfo, pAllocator, pSwapchain);
}
VkResult domVkCreateValidationCacheEXT(PFN_vkCreateValidationCacheEXT fp, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) {
return (*fp)(device, pCreateInfo, pAllocator, pValidationCache);
}
VkResult domVkDebugMarkerSetObjectNameEXT(PFN_vkDebugMarkerSetObjectNameEXT fp, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
return (*fp)(device, pNameInfo);
}
VkResult domVkDebugMarkerSetObjectTagEXT(PFN_vkDebugMarkerSetObjectTagEXT fp, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
return (*fp)(device, pTagInfo);
}
VkResult domVkDisplayPowerControlEXT(PFN_vkDisplayPowerControlEXT fp, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
return (*fp)(device, display, pDisplayPowerInfo);
}
VkResult domVkEnumeratePhysicalDeviceGroupsKHR(PFN_vkEnumeratePhysicalDeviceGroupsKHR fp, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
return (*fp)(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
}
VkResult domVkGetCalibratedTimestampsEXT(PFN_vkGetCalibratedTimestampsEXT fp, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
return (*fp)(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
}
VkResult domVkGetDeviceGroupPresentCapabilitiesKHR(PFN_vkGetDeviceGroupPresentCapabilitiesKHR fp, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
return (*fp)(device, pDeviceGroupPresentCapabilities);
}
VkResult domVkGetDeviceGroupSurfacePresentModesKHR(PFN_vkGetDeviceGroupSurfacePresentModesKHR fp, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
return (*fp)(device, surface, pModes);
}
VkResult domVkGetDisplayModeProperties2KHR(PFN_vkGetDisplayModeProperties2KHR fp, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) {
return (*fp)(physicalDevice, display, pPropertyCount, pProperties);
}
VkResult domVkGetDisplayModePropertiesKHR(PFN_vkGetDisplayModePropertiesKHR fp, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) {
return (*fp)(physicalDevice, display, pPropertyCount, pProperties);
}
VkResult domVkGetDisplayPlaneCapabilities2KHR(PFN_vkGetDisplayPlaneCapabilities2KHR fp, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) {
return (*fp)(physicalDevice, pDisplayPlaneInfo, pCapabilities);
}
VkResult domVkGetDisplayPlaneCapabilitiesKHR(PFN_vkGetDisplayPlaneCapabilitiesKHR fp, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
return (*fp)(physicalDevice, mode, planeIndex, pCapabilities);
}
VkResult domVkGetDisplayPlaneSupportedDisplaysKHR(PFN_vkGetDisplayPlaneSupportedDisplaysKHR fp, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) {
return (*fp)(physicalDevice, planeIndex, pDisplayCount, pDisplays);
}
VkResult domVkGetFenceFdKHR(PFN_vkGetFenceFdKHR fp, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
return (*fp)(device, pGetFdInfo, pFd);
}
VkResult domVkGetImageDrmFormatModifierPropertiesEXT(PFN_vkGetImageDrmFormatModifierPropertiesEXT fp, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) {
return (*fp)(device, image, pProperties);
}
VkResult domVkGetMemoryFdKHR(PFN_vkGetMemoryFdKHR fp, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {
return (*fp)(device, pGetFdInfo, pFd);
}
VkResult domVkGetMemoryFdPropertiesKHR(PFN_vkGetMemoryFdPropertiesKHR fp, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
return (*fp)(device, handleType, fd, pMemoryFdProperties);
}
VkResult domVkGetMemoryHostPointerPropertiesEXT(PFN_vkGetMemoryHostPointerPropertiesEXT fp, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
return (*fp)(device, handleType, pHostPointer, pMemoryHostPointerProperties);
}
VkResult domVkGetPastPresentationTimingGOOGLE(PFN_vkGetPastPresentationTimingGOOGLE fp, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) {
return (*fp)(device, swapchain, pPresentationTimingCount, pPresentationTimings);
}
VkResult domVkGetPhysicalDeviceCalibrateableTimeDomainsEXT(PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT fp, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) {
return (*fp)(physicalDevice, pTimeDomainCount, pTimeDomains);
}
VkResult domVkGetPhysicalDeviceDisplayPlaneProperties2KHR(PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) {
return (*fp)(physicalDevice, pPropertyCount, pProperties);
}
VkResult domVkGetPhysicalDeviceDisplayPlanePropertiesKHR(PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) {
return (*fp)(physicalDevice, pPropertyCount, pProperties);
}
VkResult domVkGetPhysicalDeviceDisplayProperties2KHR(PFN_vkGetPhysicalDeviceDisplayProperties2KHR fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) {
return (*fp)(physicalDevice, pPropertyCount, pProperties);
}
VkResult domVkGetPhysicalDeviceDisplayPropertiesKHR(PFN_vkGetPhysicalDeviceDisplayPropertiesKHR fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) {
return (*fp)(physicalDevice, pPropertyCount, pProperties);
}
VkResult domVkGetPhysicalDeviceExternalImageFormatPropertiesNV(PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV fp, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) {
return (*fp)(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
}
VkResult domVkGetPhysicalDeviceImageFormatProperties2KHR(PFN_vkGetPhysicalDeviceImageFormatProperties2KHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {
return (*fp)(physicalDevice, pImageFormatInfo, pImageFormatProperties);
}
VkResult domVkGetPhysicalDevicePresentRectanglesKHR(PFN_vkGetPhysicalDevicePresentRectanglesKHR fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) {
return (*fp)(physicalDevice, surface, pRectCount, pRects);
}
VkResult domVkGetPhysicalDeviceSurfaceCapabilities2EXT(PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
return (*fp)(physicalDevice, surface, pSurfaceCapabilities);
}
VkResult domVkGetPhysicalDeviceSurfaceCapabilities2KHR(PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
return (*fp)(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
}
VkResult domVkGetPhysicalDeviceSurfaceCapabilitiesKHR(PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
return (*fp)(physicalDevice, surface, pSurfaceCapabilities);
}
VkResult domVkGetPhysicalDeviceSurfaceFormats2KHR(PFN_vkGetPhysicalDeviceSurfaceFormats2KHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) {
return (*fp)(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
}
VkResult domVkGetPhysicalDeviceSurfaceFormatsKHR(PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
return (*fp)(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
}
VkResult domVkGetPhysicalDeviceSurfacePresentModesKHR(PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
return (*fp)(physicalDevice, surface, pPresentModeCount, pPresentModes);
}
VkResult domVkGetPhysicalDeviceSurfaceSupportKHR(PFN_vkGetPhysicalDeviceSurfaceSupportKHR fp, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
return (*fp)(physicalDevice, queueFamilyIndex, surface, pSupported);
}
VkResult domVkGetRefreshCycleDurationGOOGLE(PFN_vkGetRefreshCycleDurationGOOGLE fp, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
return (*fp)(device, swapchain, pDisplayTimingProperties);
}
VkResult domVkGetSemaphoreFdKHR(PFN_vkGetSemaphoreFdKHR fp, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
return (*fp)(device, pGetFdInfo, pFd);
}
VkResult domVkGetShaderInfoAMD(PFN_vkGetShaderInfoAMD fp, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) {
return (*fp)(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
}
VkResult domVkGetSwapchainCounterEXT(PFN_vkGetSwapchainCounterEXT fp, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) {
return (*fp)(device, swapchain, counter, pCounterValue);
}
VkResult domVkGetSwapchainImagesKHR(PFN_vkGetSwapchainImagesKHR fp, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
return (*fp)(device, swapchain, pSwapchainImageCount, pSwapchainImages);
}
VkResult domVkGetSwapchainStatusKHR(PFN_vkGetSwapchainStatusKHR fp, VkDevice device, VkSwapchainKHR swapchain) {
return (*fp)(device, swapchain);
}
VkResult domVkGetValidationCacheDataEXT(PFN_vkGetValidationCacheDataEXT fp, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) {
return (*fp)(device, validationCache, pDataSize, pData);
}
VkResult domVkImportFenceFdKHR(PFN_vkImportFenceFdKHR fp, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
return (*fp)(device, pImportFenceFdInfo);
}
VkResult domVkImportSemaphoreFdKHR(PFN_vkImportSemaphoreFdKHR fp, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
return (*fp)(device, pImportSemaphoreFdInfo);
}
VkResult domVkMergeValidationCachesEXT(PFN_vkMergeValidationCachesEXT fp, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) {
return (*fp)(device, dstCache, srcCacheCount, pSrcCaches);
}
VkResult domVkQueuePresentKHR(PFN_vkQueuePresentKHR fp, VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
return (*fp)(queue, pPresentInfo);
}
VkResult domVkRegisterDeviceEventEXT(PFN_vkRegisterDeviceEventEXT fp, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
return (*fp)(device, pDeviceEventInfo, pAllocator, pFence);
}
VkResult domVkRegisterDisplayEventEXT(PFN_vkRegisterDisplayEventEXT fp, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
return (*fp)(device, display, pDisplayEventInfo, pAllocator, pFence);
}
VkResult domVkReleaseDisplayEXT(PFN_vkReleaseDisplayEXT fp, VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
return (*fp)(physicalDevice, display);
}
VkResult domVkSetDebugUtilsObjectNameEXT(PFN_vkSetDebugUtilsObjectNameEXT fp, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
return (*fp)(device, pNameInfo);
}
VkResult domVkSetDebugUtilsObjectTagEXT(PFN_vkSetDebugUtilsObjectTagEXT fp, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
return (*fp)(device, pTagInfo);
}
void domVkCmdBeginConditionalRenderingEXT(PFN_vkCmdBeginConditionalRenderingEXT fp, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
(*fp)(commandBuffer, pConditionalRenderingBegin);
}
void domVkCmdBeginDebugUtilsLabelEXT(PFN_vkCmdBeginDebugUtilsLabelEXT fp, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {
(*fp)(commandBuffer, pLabelInfo);
}
void domVkCmdBeginQueryIndexedEXT(PFN_vkCmdBeginQueryIndexedEXT fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) {
(*fp)(commandBuffer, queryPool, query, flags, index);
}
void domVkCmdBeginRenderPass2KHR(PFN_vkCmdBeginRenderPass2KHR fp, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) {
(*fp)(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
}
void domVkCmdBeginTransformFeedbackEXT(PFN_vkCmdBeginTransformFeedbackEXT fp, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
(*fp)(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
}
void domVkCmdBindShadingRateImageNV(PFN_vkCmdBindShadingRateImageNV fp, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {
(*fp)(commandBuffer, imageView, imageLayout);
}
void domVkCmdBindTransformFeedbackBuffersEXT(PFN_vkCmdBindTransformFeedbackBuffersEXT fp, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
(*fp)(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
}
void domVkCmdDebugMarkerBeginEXT(PFN_vkCmdDebugMarkerBeginEXT fp, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
(*fp)(commandBuffer, pMarkerInfo);
}
void domVkCmdDebugMarkerEndEXT(PFN_vkCmdDebugMarkerEndEXT fp, VkCommandBuffer commandBuffer) {
(*fp)(commandBuffer);
}
void domVkCmdDebugMarkerInsertEXT(PFN_vkCmdDebugMarkerInsertEXT fp, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
(*fp)(commandBuffer, pMarkerInfo);
}
void domVkCmdDispatchBaseKHR(PFN_vkCmdDispatchBaseKHR fp, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
(*fp)(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
void domVkCmdDrawIndexedIndirectCountAMD(PFN_vkCmdDrawIndexedIndirectCountAMD fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
(*fp)(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
void domVkCmdDrawIndexedIndirectCountKHR(PFN_vkCmdDrawIndexedIndirectCountKHR fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
(*fp)(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
void domVkCmdDrawIndirectByteCountEXT(PFN_vkCmdDrawIndirectByteCountEXT fp, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) {
(*fp)(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
}
void domVkCmdDrawIndirectCountAMD(PFN_vkCmdDrawIndirectCountAMD fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
(*fp)(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
void domVkCmdDrawIndirectCountKHR(PFN_vkCmdDrawIndirectCountKHR fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
(*fp)(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
void domVkCmdDrawMeshTasksIndirectCountNV(PFN_vkCmdDrawMeshTasksIndirectCountNV fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
(*fp)(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
void domVkCmdDrawMeshTasksIndirectNV(PFN_vkCmdDrawMeshTasksIndirectNV fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
(*fp)(commandBuffer, buffer, offset, drawCount, stride);
}
void domVkCmdDrawMeshTasksNV(PFN_vkCmdDrawMeshTasksNV fp, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {
(*fp)(commandBuffer, taskCount, firstTask);
}
void domVkCmdEndConditionalRenderingEXT(PFN_vkCmdEndConditionalRenderingEXT fp, VkCommandBuffer commandBuffer) {
(*fp)(commandBuffer);
}
void domVkCmdEndDebugUtilsLabelEXT(PFN_vkCmdEndDebugUtilsLabelEXT fp, VkCommandBuffer commandBuffer) {
(*fp)(commandBuffer);
}
void domVkCmdEndQueryIndexedEXT(PFN_vkCmdEndQueryIndexedEXT fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) {
(*fp)(commandBuffer, queryPool, query, index);
}
void domVkCmdEndRenderPass2KHR(PFN_vkCmdEndRenderPass2KHR fp, VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) {
(*fp)(commandBuffer, pSubpassEndInfo);
}
void domVkCmdEndTransformFeedbackEXT(PFN_vkCmdEndTransformFeedbackEXT fp, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
(*fp)(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
}
void domVkCmdInsertDebugUtilsLabelEXT(PFN_vkCmdInsertDebugUtilsLabelEXT fp, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {
(*fp)(commandBuffer, pLabelInfo);
}
void domVkCmdNextSubpass2KHR(PFN_vkCmdNextSubpass2KHR fp, VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) {
(*fp)(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
}
void domVkCmdPushDescriptorSetKHR(PFN_vkCmdPushDescriptorSetKHR fp, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
(*fp)(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
}
void domVkCmdPushDescriptorSetWithTemplateKHR(PFN_vkCmdPushDescriptorSetWithTemplateKHR fp, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {
(*fp)(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
}
void domVkCmdSetCheckpointNV(PFN_vkCmdSetCheckpointNV fp, VkCommandBuffer commandBuffer, const void* pCheckpointMarker) {
(*fp)(commandBuffer, pCheckpointMarker);
}
void domVkCmdSetCoarseSampleOrderNV(PFN_vkCmdSetCoarseSampleOrderNV fp, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
(*fp)(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
}
void domVkCmdSetDeviceMaskKHR(PFN_vkCmdSetDeviceMaskKHR fp, VkCommandBuffer commandBuffer, uint32_t deviceMask) {
(*fp)(commandBuffer, deviceMask);
}
void domVkCmdSetDiscardRectangleEXT(PFN_vkCmdSetDiscardRectangleEXT fp, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {
(*fp)(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
}
void domVkCmdSetExclusiveScissorNV(PFN_vkCmdSetExclusiveScissorNV fp, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {
(*fp)(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
}
void domVkCmdSetSampleLocationsEXT(PFN_vkCmdSetSampleLocationsEXT fp, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
(*fp)(commandBuffer, pSampleLocationsInfo);
}
void domVkCmdSetViewportShadingRatePaletteNV(PFN_vkCmdSetViewportShadingRatePaletteNV fp, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) {
(*fp)(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
}
void domVkCmdSetViewportWScalingNV(PFN_vkCmdSetViewportWScalingNV fp, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {
(*fp)(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
}
void domVkCmdWriteBufferMarkerAMD(PFN_vkCmdWriteBufferMarkerAMD fp, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
(*fp)(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
}
void domVkDebugReportMessageEXT(PFN_vkDebugReportMessageEXT fp, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {
(*fp)(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
}
void domVkDestroyDebugReportCallbackEXT(PFN_vkDestroyDebugReportCallbackEXT fp, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {
(*fp)(instance, callback, pAllocator);
}
void domVkDestroyDebugUtilsMessengerEXT(PFN_vkDestroyDebugUtilsMessengerEXT fp, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) {
(*fp)(instance, messenger, pAllocator);
}
void domVkDestroyDescriptorUpdateTemplateKHR(PFN_vkDestroyDescriptorUpdateTemplateKHR fp, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, descriptorUpdateTemplate, pAllocator);
}
void domVkDestroySamplerYcbcrConversionKHR(PFN_vkDestroySamplerYcbcrConversionKHR fp, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, ycbcrConversion, pAllocator);
}
void domVkDestroySurfaceKHR(PFN_vkDestroySurfaceKHR fp, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
(*fp)(instance, surface, pAllocator);
}
void domVkDestroySwapchainKHR(PFN_vkDestroySwapchainKHR fp, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, swapchain, pAllocator);
}
void domVkDestroyValidationCacheEXT(PFN_vkDestroyValidationCacheEXT fp, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, validationCache, pAllocator);
}
void domVkGetBufferMemoryRequirements2KHR(PFN_vkGetBufferMemoryRequirements2KHR fp, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
(*fp)(device, pInfo, pMemoryRequirements);
}
void domVkGetDescriptorSetLayoutSupportKHR(PFN_vkGetDescriptorSetLayoutSupportKHR fp, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {
(*fp)(device, pCreateInfo, pSupport);
}
void domVkGetDeviceGroupPeerMemoryFeaturesKHR(PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR fp, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
(*fp)(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
}
void domVkGetImageMemoryRequirements2KHR(PFN_vkGetImageMemoryRequirements2KHR fp, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
(*fp)(device, pInfo, pMemoryRequirements);
}
void domVkGetImageSparseMemoryRequirements2KHR(PFN_vkGetImageSparseMemoryRequirements2KHR fp, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
(*fp)(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
void domVkGetPhysicalDeviceExternalBufferPropertiesKHR(PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {
(*fp)(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}
void domVkGetPhysicalDeviceExternalFencePropertiesKHR(PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {
(*fp)(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
void domVkGetPhysicalDeviceExternalSemaphorePropertiesKHR(PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphorePropert
B8D9
ies) {
(*fp)(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
}
void domVkGetPhysicalDeviceFeatures2KHR(PFN_vkGetPhysicalDeviceFeatures2KHR fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {
(*fp)(physicalDevice, pFeatures);
}
void domVkGetPhysicalDeviceFormatProperties2KHR(PFN_vkGetPhysicalDeviceFormatProperties2KHR fp, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {
(*fp)(physicalDevice, format, pFormatProperties);
}
void domVkGetPhysicalDeviceMemoryProperties2KHR(PFN_vkGetPhysicalDeviceMemoryProperties2KHR fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
(*fp)(physicalDevice, pMemoryProperties);
}
void domVkGetPhysicalDeviceMultisamplePropertiesEXT(PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT fp, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) {
(*fp)(physicalDevice, samples, pMultisampleProperties);
}
void domVkGetPhysicalDeviceProperties2KHR(PFN_vkGetPhysicalDeviceProperties2KHR fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {
(*fp)(physicalDevice, pProperties);
}
void domVkGetPhysicalDeviceQueueFamilyProperties2KHR(PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR fp, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {
(*fp)(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
void domVkGetPhysicalDeviceSparseImageFormatProperties2KHR(PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
(*fp)(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
}
void domVkGetQueueCheckpointDataNV(PFN_vkGetQueueCheckpointDataNV fp, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) {
(*fp)(queue, pCheckpointDataCount, pCheckpointData);
}
void domVkQueueBeginDebugUtilsLabelEXT(PFN_vkQueueBeginDebugUtilsLabelEXT fp, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
(*fp)(queue, pLabelInfo);
}
void domVkQueueEndDebugUtilsLabelEXT(PFN_vkQueueEndDebugUtilsLabelEXT fp, VkQueue queue) {
(*fp)(queue);
}
void domVkQueueInsertDebugUtilsLabelEXT(PFN_vkQueueInsertDebugUtilsLabelEXT fp, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
(*fp)(queue, pLabelInfo);
}
void domVkSetHdrMetadataEXT(PFN_vkSetHdrMetadataEXT fp, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {
(*fp)(device, swapchainCount, pSwapchains, pMetadata);
}
void domVkSubmitDebugUtilsMessageEXT(PFN_vkSubmitDebugUtilsMessageEXT fp, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
(*fp)(instance, messageSeverity, messageTypes, pCallbackData);
}
void domVkTrimCommandPoolKHR(PFN_vkTrimCommandPoolKHR fp, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
(*fp)(device, commandPool, flags);
}
void domVkUpdateDescriptorSetWithTemplateKHR(PFN_vkUpdateDescriptorSetWithTemplateKHR fp, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
(*fp)(device, descriptorSet, descriptorUpdateTemplate, pData);
}
VkResult domVkEnumerateInstanceVersion(PFN_vkEnumerateInstanceVersion fp, uint32_t* pApiVersion) {
return (*fp)(pApiVersion);
}
VkResult domVkBindImageMemory2(PFN_vkBindImageMemory2 fp, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {
return (*fp)(device, bindInfoCount, pBindInfos);
}
void domVkGetDeviceGroupPeerMemoryFeatures(PFN_vkGetDeviceGroupPeerMemoryFeatures fp, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
(*fp)(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
}
void domVkCmdDispatchBase(PFN_vkCmdDispatchBase fp, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
(*fp)(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
VkResult domVkEnumeratePhysicalDeviceGroups(PFN_vkEnumeratePhysicalDeviceGroups fp, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
return (*fp)(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
}
void domVkGetImageMemoryRequirements2(PFN_vkGetImageMemoryRequirements2 fp, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
(*fp)(device, pInfo, pMemoryRequirements);
}
void domVkGetBufferMemoryRequirements2(PFN_vkGetBufferMemoryRequirements2 fp, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
(*fp)(device, pInfo, pMemoryRequirements);
}
void domVkGetImageSparseMemoryRequirements2(PFN_vkGetImageSparseMemoryRequirements2 fp, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
(*fp)(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
void domVkGetPhysicalDeviceFeatures2(PFN_vkGetPhysicalDeviceFeatures2 fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {
(*fp)(physicalDevice, pFeatures);
}
void domVkGetPhysicalDeviceFormatProperties2(PFN_vkGetPhysicalDeviceFormatProperties2 fp, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {
(*fp)(physicalDevice, format, pFormatProperties);
}
VkResult domVkGetPhysicalDeviceImageFormatProperties2(PFN_vkGetPhysicalDeviceImageFormatProperties2 fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {
return (*fp)(physicalDevice, pImageFormatInfo, pImageFormatProperties);
}
void domVkGetPhysicalDeviceQueueFamilyProperties2(PFN_vkGetPhysicalDeviceQueueFamilyProperties2 fp, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {
(*fp)(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
void domVkGetPhysicalDeviceMemoryProperties2(PFN_vkGetPhysicalDeviceMemoryProperties2 fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
(*fp)(physicalDevice, pMemoryProperties);
}
void domVkGetPhysicalDeviceSparseImageFormatProperties2(PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
(*fp)(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
}
VkResult domVkCreateSamplerYcbcrConversion(PFN_vkCreateSamplerYcbcrConversion fp, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
return (*fp)(device, pCreateInfo, pAllocator, pYcbcrConversion);
}
void domVkDestroySamplerYcbcrConversion(PFN_vkDestroySamplerYcbcrConversion fp, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, ycbcrConversion, pAllocator);
}
VkResult domVkCreateDescriptorUpdateTemplate(PFN_vkCreateDescriptorUpdateTemplate fp, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
return (*fp)(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
}
void domVkDestroyDescriptorUpdateTemplate(PFN_vkDestroyDescriptorUpdateTemplate fp, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {
(*fp)(device, descriptorUpdateTemplate, pAllocator);
}
void domVkUpdateDescriptorSetWithTemplate(PFN_vkUpdateDescriptorSetWithTemplate fp, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
(*fp)(device, descriptorSet, descriptorUpdateTemplate, pData);
}
void domVkGetPhysicalDeviceExternalBufferProperties(PFN_vkGetPhysicalDeviceExternalBufferProperties fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {
(*fp)(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}
void domVkGetPhysicalDeviceExternalFenceProperties(PFN_vkGetPhysicalDeviceExternalFenceProperties fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {
(*fp)(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
void domVkGetPhysicalDeviceExternalSemaphoreProperties(PFN_vkGetPhysicalDeviceExternalSemaphoreProperties fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
(*fp)(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
}
void domVkGetDescriptorSetLayoutSupport(PFN_vkGetDescriptorSetLayoutSupport fp, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {
(*fp)(device, pCreateInfo, pSupport);
}