-
Notifications
You must be signed in to change notification settings - Fork 3
/
vulkan.go
2145 lines (1890 loc) · 86.6 KB
/
vulkan.go
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
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// SPDX-License-Identifier: Unlicense OR MIT
//go:build linux || freebsd
// +build linux freebsd
package vk
/*
#cgo linux freebsd LDFLAGS: -ldl
#cgo freebsd CFLAGS: -I/usr/local/include
#cgo CFLAGS: -Werror -Werror=return-type
#define VK_NO_PROTOTYPES 1
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
#include <vulkan/vulkan.h>
#define __USE_GNU
#include <dlfcn.h>
#include <stdlib.h>
static VkResult vkCreateInstance(PFN_vkCreateInstance f, VkInstanceCreateInfo pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
return f(&pCreateInfo, pAllocator, pInstance);
}
static void vkDestroyInstance(PFN_vkDestroyInstance f, VkInstance instance, const VkAllocationCallbacks *pAllocator) {
f(instance, pAllocator);
}
static VkResult vkEnumeratePhysicalDevices(PFN_vkEnumeratePhysicalDevices f, VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) {
return f(instance, pPhysicalDeviceCount, pPhysicalDevices);
}
static void vkGetPhysicalDeviceQueueFamilyProperties(PFN_vkGetPhysicalDeviceQueueFamilyProperties f, VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties) {
f(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
static void vkGetPhysicalDeviceFormatProperties(PFN_vkGetPhysicalDeviceFormatProperties f, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties) {
f(physicalDevice, format, pFormatProperties);
}
static VkResult vkCreateDevice(PFN_vkCreateDevice f, VkPhysicalDevice physicalDevice, VkDeviceCreateInfo pCreateInfo, VkDeviceQueueCreateInfo qinf, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
pCreateInfo.pQueueCreateInfos = &qinf;
return f(physicalDevice, &pCreateInfo, pAllocator, pDevice);
}
static void vkDestroyDevice(PFN_vkDestroyDevice f, VkDevice device, const VkAllocationCallbacks *pAllocator) {
f(device, pAllocator);
}
static void vkGetDeviceQueue(PFN_vkGetDeviceQueue f, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
f(device, queueFamilyIndex, queueIndex, pQueue);
}
static VkResult vkCreateImageView(PFN_vkCreateImageView f, VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
return f(device, pCreateInfo, pAllocator, pView);
}
static void vkDestroyImageView(PFN_vkDestroyImageView f, VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) {
f(device, imageView, pAllocator);
}
static VkResult vkCreateFramebuffer(PFN_vkCreateFramebuffer f, VkDevice device, VkFramebufferCreateInfo pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) {
return f(device, &pCreateInfo, pAllocator, pFramebuffer);
}
static void vkDestroyFramebuffer(PFN_vkDestroyFramebuffer f, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) {
f(device, framebuffer, pAllocator);
}
static VkResult vkDeviceWaitIdle(PFN_vkDeviceWaitIdle f, VkDevice device) {
return f(device);
}
static VkResult vkQueueWaitIdle(PFN_vkQueueWaitIdle f, VkQueue queue) {
return f(queue);
}
static VkResult vkCreateSemaphore(PFN_vkCreateSemaphore f, VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) {
return f(device, pCreateInfo, pAllocator, pSemaphore);
}
static void vkDestroySemaphore(PFN_vkDestroySemaphore f, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) {
f(device, semaphore, pAllocator);
}
static VkResult vkCreateRenderPass(PFN_vkCreateRenderPass f, VkDevice device, VkRenderPassCreateInfo pCreateInfo, VkSubpassDescription subpassInf, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) {
pCreateInfo.pSubpasses = &subpassInf;
return f(device, &pCreateInfo, pAllocator, pRenderPass);
}
static void vkDestroyRenderPass(PFN_vkDestroyRenderPass f, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) {
f(device, renderPass, pAllocator);
}
static VkResult vkCreateCommandPool(PFN_vkCreateCommandPool f, VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) {
return f(device, pCreateInfo, pAllocator, pCommandPool);
}
static void vkDestroyCommandPool(PFN_vkDestroyCommandPool f, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
f(device, commandPool, pAllocator);
}
static VkResult vkAllocateCommandBuffers(PFN_vkAllocateCommandBuffers f, VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers) {
return f(device, pAllocateInfo, pCommandBuffers);
}
static void vkFreeCommandBuffers(PFN_vkFreeCommandBuffers f, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) {
f(device, commandPool, commandBufferCount, pCommandBuffers);
}
static VkResult vkBeginCommandBuffer(PFN_vkBeginCommandBuffer f, VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo pBeginInfo) {
return f(commandBuffer, &pBeginInfo);
}
static VkResult vkEndCommandBuffer(PFN_vkEndCommandBuffer f, VkCommandBuffer commandBuffer) {
return f(commandBuffer);
}
static VkResult vkQueueSubmit(PFN_vkQueueSubmit f, VkQueue queue, VkSubmitInfo pSubmits, VkFence fence) {
return f(queue, 1, &pSubmits, fence);
}
static void vkCmdBeginRenderPass(PFN_vkCmdBeginRenderPass f, VkCommandBuffer commandBuffer, VkRenderPassBeginInfo pRenderPassBegin, VkSubpassContents contents) {
f(commandBuffer, &pRenderPassBegin, contents);
}
static void vkCmdEndRenderPass(PFN_vkCmdEndRenderPass f, VkCommandBuffer commandBuffer) {
f(commandBuffer);
}
static void vkCmdCopyBuffer(PFN_vkCmdCopyBuffer f, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) {
f(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
static void vkCmdCopyBufferToImage(PFN_vkCmdCopyBufferToImage f, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
f(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
static void vkCmdPipelineBarrier(PFN_vkCmdPipelineBarrier f, 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) {
f(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
static void vkCmdPushConstants(PFN_vkCmdPushConstants f, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues) {
f(commandBuffer, layout, stageFlags, offset, size, pValues);
}
static void vkCmdBindPipeline(PFN_vkCmdBindPipeline f, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
f(commandBuffer, pipelineBindPoint, pipeline);
}
static void vkCmdBindVertexBuffers(PFN_vkCmdBindVertexBuffers f, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) {
f(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
}
static void vkCmdSetViewport(PFN_vkCmdSetViewport f, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) {
f(commandBuffer, firstViewport, viewportCount, pViewports);
}
static void vkCmdBindIndexBuffer(PFN_vkCmdBindIndexBuffer f, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
f(commandBuffer, buffer, offset, indexType);
}
static void vkCmdDraw(PFN_vkCmdDraw f, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
f(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
static void vkCmdDrawIndexed(PFN_vkCmdDrawIndexed f, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
f(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
static void vkCmdBindDescriptorSets(PFN_vkCmdBindDescriptorSets f, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) {
f(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
static void vkCmdCopyImageToBuffer(PFN_vkCmdCopyImageToBuffer f, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
f(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
static void vkCmdDispatch(PFN_vkCmdDispatch f, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
f(commandBuffer, groupCountX, groupCountY, groupCountZ);
}
static VkResult vkCreateImage(PFN_vkCreateImage f, VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
return f(device, pCreateInfo, pAllocator, pImage);
}
static void vkDestroyImage(PFN_vkDestroyImage f, VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
f(device, image, pAllocator);
}
static void vkGetImageMemoryRequirements(PFN_vkGetImageMemoryRequirements f, VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) {
f(device, image, pMemoryRequirements);
}
static VkResult vkAllocateMemory(PFN_vkAllocateMemory f, VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) {
return f(device, pAllocateInfo, pAllocator, pMemory);
}
static VkResult vkBindImageMemory(PFN_vkBindImageMemory f, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
return f(device, image, memory, memoryOffset);
}
static void vkFreeMemory(PFN_vkFreeMemory f, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) {
f(device, memory, pAllocator);
}
static void vkGetPhysicalDeviceMemoryProperties(PFN_vkGetPhysicalDeviceMemoryProperties f, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
f(physicalDevice, pMemoryProperties);
}
static VkResult vkCreateSampler(PFN_vkCreateSampler f,VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
return f(device, pCreateInfo, pAllocator, pSampler);
}
static void vkDestroySampler(PFN_vkDestroySampler f, VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) {
f(device, sampler, pAllocator);
}
static VkResult vkCreateBuffer(PFN_vkCreateBuffer f, VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
return f(device, pCreateInfo, pAllocator, pBuffer);
}
static void vkDestroyBuffer(PFN_vkDestroyBuffer f, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) {
f(device, buffer, pAllocator);
}
static void vkGetBufferMemoryRequirements(PFN_vkGetBufferMemoryRequirements f, VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) {
f(device, buffer, pMemoryRequirements);
}
static VkResult vkBindBufferMemory(PFN_vkBindBufferMemory f, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
return f(device, buffer, memory, memoryOffset);
}
static VkResult vkCreateShaderModule(PFN_vkCreateShaderModule f, VkDevice device, VkShaderModuleCreateInfo pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) {
return f(device, &pCreateInfo, pAllocator, pShaderModule);
}
static void vkDestroyShaderModule(PFN_vkDestroyShaderModule f, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator) {
f(device, shaderModule, pAllocator);
}
static VkResult vkCreateGraphicsPipelines(PFN_vkCreateGraphicsPipelines f, VkDevice device, VkPipelineCache pipelineCache, VkGraphicsPipelineCreateInfo pCreateInfo, VkPipelineDynamicStateCreateInfo dynInf, VkPipelineColorBlendStateCreateInfo blendInf, VkPipelineVertexInputStateCreateInfo vertexInf, VkPipelineViewportStateCreateInfo viewportInf, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
pCreateInfo.pDynamicState = &dynInf;
pCreateInfo.pViewportState = &viewportInf;
pCreateInfo.pColorBlendState = &blendInf;
pCreateInfo.pVertexInputState = &vertexInf;
return f(device, pipelineCache, 1, &pCreateInfo, pAllocator, pPipelines);
}
static void vkDestroyPipeline(PFN_vkDestroyPipeline f, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) {
f(device, pipeline, pAllocator);
}
static VkResult vkCreatePipelineLayout(PFN_vkCreatePipelineLayout f, VkDevice device, VkPipelineLayoutCreateInfo pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) {
return f(device, &pCreateInfo, pAllocator, pPipelineLayout);
}
static void vkDestroyPipelineLayout(PFN_vkDestroyPipelineLayout f, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) {
f(device, pipelineLayout, pAllocator);
}
static VkResult vkCreateDescriptorSetLayout(PFN_vkCreateDescriptorSetLayout f, VkDevice device, VkDescriptorSetLayoutCreateInfo pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) {
return f(device, &pCreateInfo, pAllocator, pSetLayout);
}
static void vkDestroyDescriptorSetLayout(PFN_vkDestroyDescriptorSetLayout f, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator) {
f(device, descriptorSetLayout, pAllocator);
}
static VkResult vkMapMemory(PFN_vkMapMemory f, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) {
return f(device, memory, offset, size, flags, ppData);
}
static void vkUnmapMemory(PFN_vkUnmapMemory f, VkDevice device, VkDeviceMemory memory) {
f(device, memory);
}
static VkResult vkResetCommandBuffer(PFN_vkResetCommandBuffer f, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
return f(commandBuffer, flags);
}
static VkResult vkCreateDescriptorPool(PFN_vkCreateDescriptorPool f, VkDevice device, VkDescriptorPoolCreateInfo pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) {
return f(device, &pCreateInfo, pAllocator, pDescriptorPool);
}
static void vkDestroyDescriptorPool(PFN_vkDestroyDescriptorPool f, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) {
f(device, descriptorPool, pAllocator);
}
static VkResult vkAllocateDescriptorSets(PFN_vkAllocateDescriptorSets f, VkDevice device, VkDescriptorSetAllocateInfo pAllocateInfo, VkDescriptorSet *pDescriptorSets) {
return f(device, &pAllocateInfo, pDescriptorSets);
}
static VkResult vkFreeDescriptorSets(PFN_vkFreeDescriptorSets f, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets) {
return f(device, descriptorPool, descriptorSetCount, pDescriptorSets);
}
static void vkUpdateDescriptorSets(PFN_vkUpdateDescriptorSets f, VkDevice device, VkWriteDescriptorSet pDescriptorWrite, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) {
f(device, 1, &pDescriptorWrite, descriptorCopyCount, pDescriptorCopies);
}
static VkResult vkResetDescriptorPool(PFN_vkResetDescriptorPool f, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
return f(device, descriptorPool, flags);
}
static void vkCmdBlitImage(PFN_vkCmdBlitImage f, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
f(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
static void vkCmdCopyImage(PFN_vkCmdCopyImage f, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) {
f(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
static VkResult vkCreateComputePipelines(PFN_vkCreateComputePipelines f, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
return f(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
static VkResult vkCreateFence(PFN_vkCreateFence f, VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
return f(device, pCreateInfo, pAllocator, pFence);
}
static void vkDestroyFence(PFN_vkDestroyFence f, VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
f(device, fence, pAllocator);
}
static VkResult vkWaitForFences(PFN_vkWaitForFences f, VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) {
return f(device, fenceCount, pFences, waitAll, timeout);
}
static VkResult vkResetFences(PFN_vkResetFences f, VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
return f(device, fenceCount, pFences);
}
static void vkGetPhysicalDeviceProperties(PFN_vkGetPhysicalDeviceProperties f, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
f(physicalDevice, pProperties);
}
static VkResult vkGetPhysicalDeviceSurfaceSupportKHR(PFN_vkGetPhysicalDeviceSurfaceSupportKHR f, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported) {
return f(physicalDevice, queueFamilyIndex, surface, pSupported);
}
static void vkDestroySurfaceKHR(PFN_vkDestroySurfaceKHR f, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) {
f(instance, surface, pAllocator);
}
static VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(PFN_vkGetPhysicalDeviceSurfaceFormatsKHR f, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) {
return f(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
}
static VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(PFN_vkGetPhysicalDeviceSurfacePresentModesKHR f, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) {
return f(physicalDevice, surface, pPresentModeCount, pPresentModes);
}
static VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR f, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
return f(physicalDevice, surface, pSurfaceCapabilities);
}
static VkResult vkCreateSwapchainKHR(PFN_vkCreateSwapchainKHR f, VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
return f(device, pCreateInfo, pAllocator, pSwapchain);
}
static void vkDestroySwapchainKHR(PFN_vkDestroySwapchainKHR f, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
f(device, swapchain, pAllocator);
}
static VkResult vkGetSwapchainImagesKHR(PFN_vkGetSwapchainImagesKHR f, VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) {
return f(device, swapchain, pSwapchainImageCount, pSwapchainImages);
}
// indexAndResult holds both an integer and a result returned by value, to
// avoid Go heap allocation of the integer with Vulkan's return style.
struct intAndResult {
uint32_t uint;
VkResult res;
};
static struct intAndResult vkAcquireNextImageKHR(PFN_vkAcquireNextImageKHR f, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence) {
struct intAndResult res;
res.res = f(device, swapchain, timeout, semaphore, fence, &res.uint);
return res;
}
static VkResult vkQueuePresentKHR(PFN_vkQueuePresentKHR f, VkQueue queue, const VkPresentInfoKHR pPresentInfo) {
return f(queue, &pPresentInfo);
}
*/
import "C"
import (
"errors"
"fmt"
"image"
"math"
"reflect"
"runtime"
"sync"
"unsafe"
)
type (
AttachmentLoadOp = C.VkAttachmentLoadOp
AccessFlags = C.VkAccessFlags
BlendFactor = C.VkBlendFactor
Buffer = C.VkBuffer
BufferImageCopy = C.VkBufferImageCopy
BufferMemoryBarrier = C.VkBufferMemoryBarrier
BufferUsageFlags = C.VkBufferUsageFlags
CommandPool = C.VkCommandPool
CommandBuffer = C.VkCommandBuffer
DependencyFlags = C.VkDependencyFlags
DescriptorPool = C.VkDescriptorPool
DescriptorPoolSize = C.VkDescriptorPoolSize
DescriptorSet = C.VkDescriptorSet
DescriptorSetLayout = C.VkDescriptorSetLayout
DescriptorType = C.VkDescriptorType
Device = C.VkDevice
DeviceMemory = C.VkDeviceMemory
DeviceSize = C.VkDeviceSize
Fence = C.VkFence
Queue = C.VkQueue
IndexType = C.VkIndexType
Image = C.VkImage
ImageBlit = C.VkImageBlit
ImageCopy = C.VkImageCopy
ImageLayout = C.VkImageLayout
ImageMemoryBarrier = C.VkImageMemoryBarrier
ImageUsageFlags = C.VkImageUsageFlags
ImageView = C.VkImageView
Instance = C.VkInstance
Filter = C.VkFilter
Format = C.VkFormat
FormatFeatureFlags = C.VkFormatFeatureFlags
Framebuffer = C.VkFramebuffer
MemoryBarrier = C.VkMemoryBarrier
MemoryPropertyFlags = C.VkMemoryPropertyFlags
Pipeline = C.VkPipeline
PipelineBindPoint = C.VkPipelineBindPoint
PipelineLayout = C.VkPipelineLayout
PipelineStageFlags = C.VkPipelineStageFlags
PhysicalDevice = C.VkPhysicalDevice
PrimitiveTopology = C.VkPrimitiveTopology
PushConstantRange = C.VkPushConstantRange
QueueFamilyProperties = C.VkQueueFamilyProperties
QueueFlags = C.VkQueueFlags
RenderPass = C.VkRenderPass
Sampler = C.VkSampler
SamplerMipmapMode = C.VkSamplerMipmapMode
Semaphore = C.VkSemaphore
ShaderModule = C.VkShaderModule
ShaderStageFlags = C.VkShaderStageFlags
SubpassDependency = C.VkSubpassDependency
Viewport = C.VkViewport
WriteDescriptorSet = C.VkWriteDescriptorSet
Surface = C.VkSurfaceKHR
SurfaceCapabilities = C.VkSurfaceCapabilitiesKHR
Swapchain = C.VkSwapchainKHR
)
type VertexInputBindingDescription struct {
Binding int
Stride int
}
type VertexInputAttributeDescription struct {
Location int
Binding int
Format Format
Offset int
}
type DescriptorSetLayoutBinding struct {
Binding int
DescriptorType DescriptorType
StageFlags ShaderStageFlags
}
type Error C.VkResult
const (
FORMAT_R8G8B8A8_UNORM Format = C.VK_FORMAT_R8G8B8A8_UNORM
FORMAT_B8G8R8A8_SRGB Format = C.VK_FORMAT_B8G8R8A8_SRGB
FORMAT_R8G8B8A8_SRGB Format = C.VK_FORMAT_R8G8B8A8_SRGB
FORMAT_R16_SFLOAT Format = C.VK_FORMAT_R16_SFLOAT
FORMAT_R32_SFLOAT Format = C.VK_FORMAT_R32_SFLOAT
FORMAT_R32G32_SFLOAT Format = C.VK_FORMAT_R32G32_SFLOAT
FORMAT_R32G32B32_SFLOAT Format = C.VK_FORMAT_R32G32B32_SFLOAT
FORMAT_R32G32B32A32_SFLOAT Format = C.VK_FORMAT_R32G32B32A32_SFLOAT
FORMAT_FEATURE_COLOR_ATTACHMENT_BIT FormatFeatureFlags = C.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT FormatFeatureFlags = C.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
FORMAT_FEATURE_SAMPLED_IMAGE_BIT FormatFeatureFlags = C.VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT FormatFeatureFlags = C.VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
IMAGE_USAGE_SAMPLED_BIT ImageUsageFlags = C.VK_IMAGE_USAGE_SAMPLED_BIT
IMAGE_USAGE_COLOR_ATTACHMENT_BIT ImageUsageFlags = C.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
IMAGE_USAGE_STORAGE_BIT ImageUsageFlags = C.VK_IMAGE_USAGE_STORAGE_BIT
IMAGE_USAGE_TRANSFER_DST_BIT ImageUsageFlags = C.VK_IMAGE_USAGE_TRANSFER_DST_BIT
IMAGE_USAGE_TRANSFER_SRC_BIT ImageUsageFlags = C.VK_IMAGE_USAGE_TRANSFER_SRC_BIT
FILTER_NEAREST Filter = C.VK_FILTER_NEAREST
FILTER_LINEAR Filter = C.VK_FILTER_LINEAR
ATTACHMENT_LOAD_OP_CLEAR AttachmentLoadOp = C.VK_ATTACHMENT_LOAD_OP_CLEAR
ATTACHMENT_LOAD_OP_DONT_CARE AttachmentLoadOp = C.VK_ATTACHMENT_LOAD_OP_DONT_CARE
ATTACHMENT_LOAD_OP_LOAD AttachmentLoadOp = C.VK_ATTACHMENT_LOAD_OP_LOAD
IMAGE_LAYOUT_UNDEFINED ImageLayout = C.VK_IMAGE_LAYOUT_UNDEFINED
IMAGE_LAYOUT_PRESENT_SRC_KHR ImageLayout = C.VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL ImageLayout = C.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL ImageLayout = C.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL ImageLayout = C.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL ImageLayout = C.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
IMAGE_LAYOUT_GENERAL ImageLayout = C.VK_IMAGE_LAYOUT_GENERAL
BUFFER_USAGE_TRANSFER_DST_BIT BufferUsageFlags = C.VK_BUFFER_USAGE_TRANSFER_DST_BIT
BUFFER_USAGE_TRANSFER_SRC_BIT BufferUsageFlags = C.VK_BUFFER_USAGE_TRANSFER_SRC_BIT
BUFFER_USAGE_UNIFORM_BUFFER_BIT BufferUsageFlags = C.VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
BUFFER_USAGE_STORAGE_BUFFER_BIT BufferUsageFlags = C.VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
BUFFER_USAGE_INDEX_BUFFER_BIT BufferUsageFlags = C.VK_BUFFER_USAGE_INDEX_BUFFER_BIT
BUFFER_USAGE_VERTEX_BUFFER_BIT BufferUsageFlags = C.VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
ERROR_OUT_OF_DATE_KHR = Error(C.VK_ERROR_OUT_OF_DATE_KHR)
ERROR_SURFACE_LOST_KHR = Error(C.VK_ERROR_SURFACE_LOST_KHR)
ERROR_DEVICE_LOST = Error(C.VK_ERROR_DEVICE_LOST)
SUBOPTIMAL_KHR = Error(C.VK_SUBOPTIMAL_KHR)
FENCE_CREATE_SIGNALED_BIT = 0x00000001
BLEND_FACTOR_ZERO BlendFactor = C.VK_BLEND_FACTOR_ZERO
BLEND_FACTOR_ONE BlendFactor = C.VK_BLEND_FACTOR_ONE
BLEND_FACTOR_ONE_MINUS_SRC_ALPHA BlendFactor = C.VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
BLEND_FACTOR_DST_COLOR BlendFactor = C.VK_BLEND_FACTOR_DST_COLOR
PRIMITIVE_TOPOLOGY_TRIANGLE_LIST PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
SHADER_STAGE_VERTEX_BIT ShaderStageFlags = C.VK_SHADER_STAGE_VERTEX_BIT
SHADER_STAGE_FRAGMENT_BIT ShaderStageFlags = C.VK_SHADER_STAGE_FRAGMENT_BIT
SHADER_STAGE_COMPUTE_BIT ShaderStageFlags = C.VK_SHADER_STAGE_COMPUTE_BIT
DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER DescriptorType = C.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
DESCRIPTOR_TYPE_UNIFORM_BUFFER DescriptorType = C.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
DESCRIPTOR_TYPE_STORAGE_BUFFER DescriptorType = C.VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
DESCRIPTOR_TYPE_STORAGE_IMAGE DescriptorType = C.VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
MEMORY_PROPERTY_DEVICE_LOCAL_BIT MemoryPropertyFlags = C.VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
MEMORY_PROPERTY_HOST_VISIBLE_BIT MemoryPropertyFlags = C.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
MEMORY_PROPERTY_HOST_COHERENT_BIT MemoryPropertyFlags = C.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
DEPENDENCY_BY_REGION_BIT DependencyFlags = C.VK_DEPENDENCY_BY_REGION_BIT
PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT PipelineStageFlags = C.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
PIPELINE_STAGE_TRANSFER_BIT PipelineStageFlags = C.VK_PIPELINE_STAGE_TRANSFER_BIT
PIPELINE_STAGE_FRAGMENT_SHADER_BIT PipelineStageFlags = C.VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
PIPELINE_STAGE_COMPUTE_SHADER_BIT PipelineStageFlags = C.VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
PIPELINE_STAGE_TOP_OF_PIPE_BIT PipelineStageFlags = C.VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
PIPELINE_STAGE_HOST_BIT PipelineStageFlags = C.VK_PIPELINE_STAGE_HOST_BIT
PIPELINE_STAGE_VERTEX_INPUT_BIT PipelineStageFlags = C.VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT PipelineStageFlags = C.VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
ACCESS_MEMORY_READ_BIT AccessFlags = C.VK_ACCESS_MEMORY_READ_BIT
ACCESS_MEMORY_WRITE_BIT AccessFlags = C.VK_ACCESS_MEMORY_WRITE_BIT
ACCESS_TRANSFER_READ_BIT AccessFlags = C.VK_ACCESS_TRANSFER_READ_BIT
ACCESS_TRANSFER_WRITE_BIT AccessFlags = C.VK_ACCESS_TRANSFER_WRITE_BIT
ACCESS_SHADER_READ_BIT AccessFlags = C.VK_ACCESS_SHADER_READ_BIT
ACCESS_SHADER_WRITE_BIT AccessFlags = C.VK_ACCESS_SHADER_WRITE_BIT
ACCESS_COLOR_ATTACHMENT_READ_BIT AccessFlags = C.VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
ACCESS_COLOR_ATTACHMENT_WRITE_BIT AccessFlags = C.VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
ACCESS_HOST_READ_BIT AccessFlags = C.VK_ACCESS_HOST_READ_BIT
ACCESS_HOST_WRITE_BIT AccessFlags = C.VK_ACCESS_HOST_WRITE_BIT
ACCESS_VERTEX_ATTRIBUTE_READ_BIT AccessFlags = C.VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
ACCESS_INDEX_READ_BIT AccessFlags = C.VK_ACCESS_INDEX_READ_BIT
PIPELINE_BIND_POINT_COMPUTE PipelineBindPoint = C.VK_PIPELINE_BIND_POINT_COMPUTE
PIPELINE_BIND_POINT_GRAPHICS PipelineBindPoint = C.VK_PIPELINE_BIND_POINT_GRAPHICS
INDEX_TYPE_UINT16 IndexType = C.VK_INDEX_TYPE_UINT16
INDEX_TYPE_UINT32 IndexType = C.VK_INDEX_TYPE_UINT32
QUEUE_GRAPHICS_BIT QueueFlags = C.VK_QUEUE_GRAPHICS_BIT
QUEUE_COMPUTE_BIT QueueFlags = C.VK_QUEUE_COMPUTE_BIT
SAMPLER_MIPMAP_MODE_NEAREST SamplerMipmapMode = C.VK_SAMPLER_MIPMAP_MODE_NEAREST
SAMPLER_MIPMAP_MODE_LINEAR SamplerMipmapMode = C.VK_SAMPLER_MIPMAP_MODE_LINEAR
REMAINING_MIP_LEVELS = -1
)
var (
once sync.Once
loadErr error
loadFuncs []func(dlopen func(name string) *[0]byte)
)
var funcs struct {
vkCreateInstance C.PFN_vkCreateInstance
vkDestroyInstance C.PFN_vkDestroyInstance
vkEnumeratePhysicalDevices C.PFN_vkEnumeratePhysicalDevices
vkGetPhysicalDeviceQueueFamilyProperties C.PFN_vkGetPhysicalDeviceQueueFamilyProperties
vkGetPhysicalDeviceFormatProperties C.PFN_vkGetPhysicalDeviceFormatProperties
vkCreateDevice C.PFN_vkCreateDevice
vkDestroyDevice C.PFN_vkDestroyDevice
vkGetDeviceQueue C.PFN_vkGetDeviceQueue
vkCreateImageView C.PFN_vkCreateImageView
vkDestroyImageView C.PFN_vkDestroyImageView
vkCreateFramebuffer C.PFN_vkCreateFramebuffer
vkDestroyFramebuffer C.PFN_vkDestroyFramebuffer
vkDeviceWaitIdle C.PFN_vkDeviceWaitIdle
vkQueueWaitIdle C.PFN_vkQueueWaitIdle
vkCreateSemaphore C.PFN_vkCreateSemaphore
vkDestroySemaphore C.PFN_vkDestroySemaphore
vkCreateRenderPass C.PFN_vkCreateRenderPass
vkDestroyRenderPass C.PFN_vkDestroyRenderPass
vkCreateCommandPool C.PFN_vkCreateCommandPool
vkDestroyCommandPool C.PFN_vkDestroyCommandPool
vkAllocateCommandBuffers C.PFN_vkAllocateCommandBuffers
vkFreeCommandBuffers C.PFN_vkFreeCommandBuffers
vkBeginCommandBuffer C.PFN_vkBeginCommandBuffer
vkEndCommandBuffer C.PFN_vkEndCommandBuffer
vkQueueSubmit C.PFN_vkQueueSubmit
vkCmdBeginRenderPass C.PFN_vkCmdBeginRenderPass
vkCmdEndRenderPass C.PFN_vkCmdEndRenderPass
vkCmdCopyBuffer C.PFN_vkCmdCopyBuffer
vkCmdCopyBufferToImage C.PFN_vkCmdCopyBufferToImage
vkCmdPipelineBarrier C.PFN_vkCmdPipelineBarrier
vkCmdPushConstants C.PFN_vkCmdPushConstants
vkCmdBindPipeline C.PFN_vkCmdBindPipeline
vkCmdBindVertexBuffers C.PFN_vkCmdBindVertexBuffers
vkCmdSetViewport C.PFN_vkCmdSetViewport
vkCmdBindIndexBuffer C.PFN_vkCmdBindIndexBuffer
vkCmdDraw C.PFN_vkCmdDraw
vkCmdDrawIndexed C.PFN_vkCmdDrawIndexed
vkCmdBindDescriptorSets C.PFN_vkCmdBindDescriptorSets
vkCmdCopyImageToBuffer C.PFN_vkCmdCopyImageToBuffer
vkCmdDispatch C.PFN_vkCmdDispatch
vkCreateImage C.PFN_vkCreateImage
vkDestroyImage C.PFN_vkDestroyImage
vkGetImageMemoryRequirements C.PFN_vkGetImageMemoryRequirements
vkAllocateMemory C.PFN_vkAllocateMemory
vkBindImageMemory C.PFN_vkBindImageMemory
vkFreeMemory C.PFN_vkFreeMemory
vkGetPhysicalDeviceMemoryProperties C.PFN_vkGetPhysicalDeviceMemoryProperties
vkCreateSampler C.PFN_vkCreateSampler
vkDestroySampler C.PFN_vkDestroySampler
vkCreateBuffer C.PFN_vkCreateBuffer
vkDestroyBuffer C.PFN_vkDestroyBuffer
vkGetBufferMemoryRequirements C.PFN_vkGetBufferMemoryRequirements
vkBindBufferMemory C.PFN_vkBindBufferMemory
vkCreateShaderModule C.PFN_vkCreateShaderModule
vkDestroyShaderModule C.PFN_vkDestroyShaderModule
vkCreateGraphicsPipelines C.PFN_vkCreateGraphicsPipelines
vkDestroyPipeline C.PFN_vkDestroyPipeline
vkCreatePipelineLayout C.PFN_vkCreatePipelineLayout
vkDestroyPipelineLayout C.PFN_vkDestroyPipelineLayout
vkCreateDescriptorSetLayout C.PFN_vkCreateDescriptorSetLayout
vkDestroyDescriptorSetLayout C.PFN_vkDestroyDescriptorSetLayout
vkMapMemory C.PFN_vkMapMemory
vkUnmapMemory C.PFN_vkUnmapMemory
vkResetCommandBuffer C.PFN_vkResetCommandBuffer
vkCreateDescriptorPool C.PFN_vkCreateDescriptorPool
vkDestroyDescriptorPool C.PFN_vkDestroyDescriptorPool
vkAllocateDescriptorSets C.PFN_vkAllocateDescriptorSets
vkFreeDescriptorSets C.PFN_vkFreeDescriptorSets
vkUpdateDescriptorSets C.PFN_vkUpdateDescriptorSets
vkResetDescriptorPool C.PFN_vkResetDescriptorPool
vkCmdBlitImage C.PFN_vkCmdBlitImage
vkCmdCopyImage C.PFN_vkCmdCopyImage
vkCreateComputePipelines C.PFN_vkCreateComputePipelines
vkCreateFence C.PFN_vkCreateFence
vkDestroyFence C.PFN_vkDestroyFence
vkWaitForFences C.PFN_vkWaitForFences
vkResetFences C.PFN_vkResetFences
vkGetPhysicalDeviceProperties C.PFN_vkGetPhysicalDeviceProperties
vkGetPhysicalDeviceSurfaceSupportKHR C.PFN_vkGetPhysicalDeviceSurfaceSupportKHR
vkDestroySurfaceKHR C.PFN_vkDestroySurfaceKHR
vkGetPhysicalDeviceSurfaceFormatsKHR C.PFN_vkGetPhysicalDeviceSurfaceFormatsKHR
vkGetPhysicalDeviceSurfacePresentModesKHR C.PFN_vkGetPhysicalDeviceSurfacePresentModesKHR
vkGetPhysicalDeviceSurfaceCapabilitiesKHR C.PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
vkCreateSwapchainKHR C.PFN_vkCreateSwapchainKHR
vkDestroySwapchainKHR C.PFN_vkDestroySwapchainKHR
vkGetSwapchainImagesKHR C.PFN_vkGetSwapchainImagesKHR
vkAcquireNextImageKHR C.PFN_vkAcquireNextImageKHR
vkQueuePresentKHR C.PFN_vkQueuePresentKHR
}
var (
nilSurface C.VkSurfaceKHR
nilSwapchain C.VkSwapchainKHR
nilSemaphore C.VkSemaphore
nilImageView C.VkImageView
nilRenderPass C.VkRenderPass
nilFramebuffer C.VkFramebuffer
nilCommandPool C.VkCommandPool
nilImage C.VkImage
nilDeviceMemory C.VkDeviceMemory
nilSampler C.VkSampler
nilBuffer C.VkBuffer
nilShaderModule C.VkShaderModule
nilPipeline C.VkPipeline
nilPipelineCache C.VkPipelineCache
nilPipelineLayout C.VkPipelineLayout
nilDescriptorSetLayout C.VkDescriptorSetLayout
nilDescriptorPool C.VkDescriptorPool
nilDescriptorSet C.VkDescriptorSet
nilFence C.VkFence
)
func vkInit() error {
once.Do(func() {
var libName string
switch {
case runtime.GOOS == "android":
libName = "libvulkan.so"
default:
libName = "libvulkan.so.1"
}
lib := dlopen(libName)
if lib == nil {
loadErr = fmt.Errorf("vulkan: %s", C.GoString(C.dlerror()))
return
}
dlopen := func(name string) *[0]byte {
return (*[0]byte)(dlsym(lib, name))
}
must := func(name string) *[0]byte {
ptr := dlopen(name)
if ptr != nil {
return ptr
}
if loadErr == nil {
loadErr = fmt.Errorf("vulkan: function %q not found: %s", name, C.GoString(C.dlerror()))
}
return nil
}
funcs.vkCreateInstance = must("vkCreateInstance")
funcs.vkDestroyInstance = must("vkDestroyInstance")
funcs.vkEnumeratePhysicalDevices = must("vkEnumeratePhysicalDevices")
funcs.vkGetPhysicalDeviceQueueFamilyProperties = must("vkGetPhysicalDeviceQueueFamilyProperties")
funcs.vkGetPhysicalDeviceFormatProperties = must("vkGetPhysicalDeviceFormatProperties")
funcs.vkCreateDevice = must("vkCreateDevice")
funcs.vkDestroyDevice = must("vkDestroyDevice")
funcs.vkGetDeviceQueue = must("vkGetDeviceQueue")
funcs.vkCreateImageView = must("vkCreateImageView")
funcs.vkDestroyImageView = must("vkDestroyImageView")
funcs.vkCreateFramebuffer = must("vkCreateFramebuffer")
funcs.vkDestroyFramebuffer = must("vkDestroyFramebuffer")
funcs.vkDeviceWaitIdle = must("vkDeviceWaitIdle")
funcs.vkQueueWaitIdle = must("vkQueueWaitIdle")
funcs.vkCreateSemaphore = must("vkCreateSemaphore")
funcs.vkDestroySemaphore = must("vkDestroySemaphore")
funcs.vkCreateRenderPass = must("vkCreateRenderPass")
funcs.vkDestroyRenderPass = must("vkDestroyRenderPass")
funcs.vkCreateCommandPool = must("vkCreateCommandPool")
funcs.vkDestroyCommandPool = must("vkDestroyCommandPool")
funcs.vkAllocateCommandBuffers = must("vkAllocateCommandBuffers")
funcs.vkFreeCommandBuffers = must("vkFreeCommandBuffers")
funcs.vkBeginCommandBuffer = must("vkBeginCommandBuffer")
funcs.vkEndCommandBuffer = must("vkEndCommandBuffer")
funcs.vkQueueSubmit = must("vkQueueSubmit")
funcs.vkCmdBeginRenderPass = must("vkCmdBeginRenderPass")
funcs.vkCmdEndRenderPass = must("vkCmdEndRenderPass")
funcs.vkCmdCopyBuffer = must("vkCmdCopyBuffer")
funcs.vkCmdCopyBufferToImage = must("vkCmdCopyBufferToImage")
funcs.vkCmdPipelineBarrier = must("vkCmdPipelineBarrier")
funcs.vkCmdPushConstants = must("vkCmdPushConstants")
funcs.vkCmdBindPipeline = must("vkCmdBindPipeline")
funcs.vkCmdBindVertexBuffers = must("vkCmdBindVertexBuffers")
funcs.vkCmdSetViewport = must("vkCmdSetViewport")
funcs.vkCmdBindIndexBuffer = must("vkCmdBindIndexBuffer")
funcs.vkCmdDraw = must("vkCmdDraw")
funcs.vkCmdDrawIndexed = must("vkCmdDrawIndexed")
funcs.vkCmdBindDescriptorSets = must("vkCmdBindDescriptorSets")
funcs.vkCmdCopyImageToBuffer = must("vkCmdCopyImageToBuffer")
funcs.vkCmdDispatch = must("vkCmdDispatch")
funcs.vkCreateImage = must("vkCreateImage")
funcs.vkDestroyImage = must("vkDestroyImage")
funcs.vkGetImageMemoryRequirements = must("vkGetImageMemoryRequirements")
funcs.vkAllocateMemory = must("vkAllocateMemory")
funcs.vkBindImageMemory = must("vkBindImageMemory")
funcs.vkFreeMemory = must("vkFreeMemory")
funcs.vkGetPhysicalDeviceMemoryProperties = must("vkGetPhysicalDeviceMemoryProperties")
funcs.vkCreateSampler = must("vkCreateSampler")
funcs.vkDestroySampler = must("vkDestroySampler")
funcs.vkCreateBuffer = must("vkCreateBuffer")
funcs.vkDestroyBuffer = must("vkDestroyBuffer")
funcs.vkGetBufferMemoryRequirements = must("vkGetBufferMemoryRequirements")
funcs.vkBindBufferMemory = must("vkBindBufferMemory")
funcs.vkCreateShaderModule = must("vkCreateShaderModule")
funcs.vkDestroyShaderModule = must("vkDestroyShaderModule")
funcs.vkCreateGraphicsPipelines = must("vkCreateGraphicsPipelines")
funcs.vkDestroyPipeline = must("vkDestroyPipeline")
funcs.vkCreatePipelineLayout = must("vkCreatePipelineLayout")
funcs.vkDestroyPipelineLayout = must("vkDestroyPipelineLayout")
funcs.vkCreateDescriptorSetLayout = must("vkCreateDescriptorSetLayout")
funcs.vkDestroyDescriptorSetLayout = must("vkDestroyDescriptorSetLayout")
funcs.vkMapMemory = must("vkMapMemory")
funcs.vkUnmapMemory = must("vkUnmapMemory")
funcs.vkResetCommandBuffer = must("vkResetCommandBuffer")
funcs.vkCreateDescriptorPool = must("vkCreateDescriptorPool")
funcs.vkDestroyDescriptorPool = must("vkDestroyDescriptorPool")
funcs.vkAllocateDescriptorSets = must("vkAllocateDescriptorSets")
funcs.vkFreeDescriptorSets = must("vkFreeDescriptorSets")
funcs.vkUpdateDescriptorSets = must("vkUpdateDescriptorSets")
funcs.vkResetDescriptorPool = must("vkResetDescriptorPool")
funcs.vkCmdBlitImage = must("vkCmdBlitImage")
funcs.vkCmdCopyImage = must("vkCmdCopyImage")
funcs.vkCreateComputePipelines = must("vkCreateComputePipelines")
funcs.vkCreateFence = must("vkCreateFence")
funcs.vkDestroyFence = must("vkDestroyFence")
funcs.vkWaitForFences = must("vkWaitForFences")
funcs.vkResetFences = must("vkResetFences")
funcs.vkGetPhysicalDeviceProperties = must("vkGetPhysicalDeviceProperties")
funcs.vkGetPhysicalDeviceSurfaceSupportKHR = dlopen("vkGetPhysicalDeviceSurfaceSupportKHR")
funcs.vkDestroySurfaceKHR = dlopen("vkDestroySurfaceKHR")
funcs.vkGetPhysicalDeviceSurfaceFormatsKHR = dlopen("vkGetPhysicalDeviceSurfaceFormatsKHR")
funcs.vkGetPhysicalDeviceSurfacePresentModesKHR = dlopen("vkGetPhysicalDeviceSurfacePresentModesKHR")
funcs.vkGetPhysicalDeviceSurfaceCapabilitiesKHR = dlopen("vkGetPhysicalDeviceSurfaceCapabilitiesKHR")
funcs.vkCreateSwapchainKHR = dlopen("vkCreateSwapchainKHR")
funcs.vkDestroySwapchainKHR = dlopen("vkDestroySwapchainKHR")
funcs.vkGetSwapchainImagesKHR = dlopen("vkGetSwapchainImagesKHR")
funcs.vkAcquireNextImageKHR = dlopen("vkAcquireNextImageKHR")
funcs.vkQueuePresentKHR = dlopen("vkQueuePresentKHR")
for _, f := range loadFuncs {
f(dlopen)
}
})
return loadErr
}
func CreateInstance(exts ...string) (Instance, error) {
if err := vkInit(); err != nil {
return nil, err
}
// VK_MAKE_API_VERSION macro.
makeVer := func(variant, major, minor, patch int) C.uint32_t {
return ((((C.uint32_t)(variant)) << 29) | (((C.uint32_t)(major)) << 22) | (((C.uint32_t)(minor)) << 12) | ((C.uint32_t)(patch)))
}
appInf := C.VkApplicationInfo{
sType: C.VK_STRUCTURE_TYPE_APPLICATION_INFO,
apiVersion: makeVer(0, 1, 0, 0),
}
inf := C.VkInstanceCreateInfo{
sType: C.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
// pApplicationInfo may be omitted according to the spec, but the Android
// emulator crashes without it.
pApplicationInfo: &appInf,
}
if len(exts) > 0 {
cexts := mallocCStringArr(exts)
defer freeCStringArr(cexts)
inf.enabledExtensionCount = C.uint32_t(len(exts))
inf.ppEnabledExtensionNames = &cexts[0]
}
var inst Instance
if err := vkErr(C.vkCreateInstance(funcs.vkCreateInstance, inf, nil, &inst)); err != nil {
return nil, fmt.Errorf("vulkan: vkCreateInstance: %w", err)
}
return inst, nil
}
func mallocCStringArr(s []string) []*C.char {
carr := make([]*C.char, len(s))
for i, ext := range s {
carr[i] = C.CString(ext)
}
return carr
}
func freeCStringArr(s []*C.char) {
for i := range s {
C.free(unsafe.Pointer(s[i]))
s[i] = nil
}
}
func DestroyInstance(inst Instance) {
C.vkDestroyInstance(funcs.vkDestroyInstance, inst, nil)
}
func GetPhysicalDeviceQueueFamilyProperties(pd PhysicalDevice) []QueueFamilyProperties {
var count C.uint32_t
C.vkGetPhysicalDeviceQueueFamilyProperties(funcs.vkGetPhysicalDeviceQueueFamilyProperties, pd, &count, nil)
if count == 0 {
return nil
}
queues := make([]C.VkQueueFamilyProperties, count)
C.vkGetPhysicalDeviceQueueFamilyProperties(funcs.vkGetPhysicalDeviceQueueFamilyProperties, pd, &count, &queues[0])
return queues
}
func EnumeratePhysicalDevices(inst Instance) ([]PhysicalDevice, error) {
var count C.uint32_t
if err := vkErr(C.vkEnumeratePhysicalDevices(funcs.vkEnumeratePhysicalDevices, inst, &count, nil)); err != nil {
return nil, fmt.Errorf("vulkan: vkEnumeratePhysicalDevices: %w", err)
}
if count == 0 {
return nil, nil
}
devs := make([]C.VkPhysicalDevice, count)
if err := vkErr(C.vkEnumeratePhysicalDevices(funcs.vkEnumeratePhysicalDevices, inst, &count, &devs[0])); err != nil {
return nil, fmt.Errorf("vulkan: vkEnumeratePhysicalDevices: %w", err)
}
return devs, nil
}
func ChoosePhysicalDevice(inst Instance, surf Surface) (PhysicalDevice, int, error) {
devs, err := EnumeratePhysicalDevices(inst)
if err != nil {
return nil, 0, err
}
for _, pd := range devs {
var props C.VkPhysicalDeviceProperties
C.vkGetPhysicalDeviceProperties(funcs.vkGetPhysicalDeviceProperties, pd, &props)
// The lavapipe software implementation doesn't work well rendering to a surface.
// See https://gitlab.freedesktop.org/mesa/mesa/-/issues/5473.
if surf != 0 && props.deviceType == C.VK_PHYSICAL_DEVICE_TYPE_CPU {
continue
}
const caps = C.VK_QUEUE_GRAPHICS_BIT | C.VK_QUEUE_COMPUTE_BIT
queueIdx, ok, err := chooseQueue(pd, surf, caps)
if err != nil {
return nil, 0, err
}
if !ok {
continue
}
if surf != nilSurface {
_, fmtFound, err := chooseFormat(pd, surf)
if err != nil {
return nil, 0, err
}
_, modFound, err := choosePresentMode(pd, surf)
if err != nil {
return nil, 0, err
}
if !fmtFound || !modFound {
continue
}
}
return pd, queueIdx, nil
}
return nil, 0, errors.New("vulkan: no suitable device found")
}
func CreateDeviceAndQueue(pd C.VkPhysicalDevice, queueIdx int, exts ...string) (Device, error) {
priority := C.float(1.0)
qinf := C.VkDeviceQueueCreateInfo{
sType: C.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
queueCount: 1,
queueFamilyIndex: C.uint32_t(queueIdx),
pQueuePriorities: &priority,
}
inf := C.VkDeviceCreateInfo{
sType: C.VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
queueCreateInfoCount: 1,
enabledExtensionCount: C.uint32_t(len(exts)),
}
if len(exts) > 0 {
cexts := mallocCStringArr(exts)
defer freeCStringArr(cexts)
inf.ppEnabledExtensionNames = &cexts[0]
}
var dev Device
if err := vkErr(C.vkCreateDevice(funcs.vkCreateDevice, pd, inf, qinf, nil, &dev)); err != nil {
return nil, fmt.Errorf("vulkan: vkCreateDevice: %w", err)
}
return dev, nil
}
func GetDeviceQueue(d Device, queueFamily, queueIndex int) Queue {
var queue Queue
C.vkGetDeviceQueue(funcs.vkGetDeviceQueue, d, C.uint32_t(queueFamily), C.uint32_t(queueIndex), &queue)
return queue
}
func GetPhysicalDeviceSurfaceCapabilities(pd PhysicalDevice, surf Surface) (SurfaceCapabilities, error) {
var caps C.VkSurfaceCapabilitiesKHR
err := vkErr(C.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(funcs.vkGetPhysicalDeviceSurfaceCapabilitiesKHR, pd, surf, &caps))
if err != nil {
return SurfaceCapabilities{}, fmt.Errorf("vulkan: vkGetPhysicalDeviceSurfaceCapabilitiesKHR: %w", err)
}
return caps, nil
}
func CreateSwapchain(pd PhysicalDevice, d Device, surf Surface, width, height int, old Swapchain) (Swapchain, []Image, Format, error) {
caps, err := GetPhysicalDeviceSurfaceCapabilities(pd, surf)
if err != nil {
return nilSwapchain, nil, 0, err
}
mode, modeOK, err := choosePresentMode(pd, surf)
if err != nil {
return nilSwapchain, nil, 0, err
}