forked from godotengine/godot
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathspirv_reflect.h
2465 lines (2095 loc) · 94 KB
/
spirv_reflect.h
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
/*
Copyright 2017-2022 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/*
VERSION HISTORY
1.0 (2018-03-27) Initial public release
*/
// clang-format off
/*!
@file spirv_reflect.h
*/
#ifndef SPIRV_REFLECT_H
#define SPIRV_REFLECT_H
#if defined(SPIRV_REFLECT_USE_SYSTEM_SPIRV_H)
#include <spirv/unified1/spirv.h>
#else
#include "./include/spirv/unified1/spirv.h"
#endif
#include <stdint.h>
#include <string.h>
#ifdef _MSC_VER
#define SPV_REFLECT_DEPRECATED(msg_str) __declspec(deprecated("This symbol is deprecated. Details: " msg_str))
#elif defined(__clang__)
#define SPV_REFLECT_DEPRECATED(msg_str) __attribute__((deprecated(msg_str)))
#elif defined(__GNUC__)
#if GCC_VERSION >= 40500
#define SPV_REFLECT_DEPRECATED(msg_str) __attribute__((deprecated(msg_str)))
#else
#define SPV_REFLECT_DEPRECATED(msg_str) __attribute__((deprecated))
#endif
#else
#define SPV_REFLECT_DEPRECATED(msg_str)
#endif
/*! @enum SpvReflectResult
*/
typedef enum SpvReflectResult {
SPV_REFLECT_RESULT_SUCCESS,
SPV_REFLECT_RESULT_NOT_READY,
SPV_REFLECT_RESULT_ERROR_PARSE_FAILED,
SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED,
SPV_REFLECT_RESULT_ERROR_RANGE_EXCEEDED,
SPV_REFLECT_RESULT_ERROR_NULL_POINTER,
SPV_REFLECT_RESULT_ERROR_INTERNAL_ERROR,
SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH,
SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND,
SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_CODE_SIZE,
SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_MAGIC_NUMBER,
SPV_REFLECT_RESULT_ERROR_SPIRV_UNEXPECTED_EOF,
SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE,
SPV_REFLECT_RESULT_ERROR_SPIRV_SET_NUMBER_OVERFLOW,
SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_STORAGE_CLASS,
SPV_REFLECT_RESULT_ERROR_SPIRV_RECURSION,
SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_INSTRUCTION,
SPV_REFLECT_RESULT_ERROR_SPIRV_UNEXPECTED_BLOCK_DATA,
SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_BLOCK_MEMBER_REFERENCE,
SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ENTRY_POINT,
SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_EXECUTION_MODE,
SPV_REFLECT_RESULT_ERROR_SPIRV_MAX_RECURSIVE_EXCEEDED,
} SpvReflectResult;
/*! @enum SpvReflectModuleFlagBits
SPV_REFLECT_MODULE_FLAG_NO_COPY - Disables copying of SPIR-V code
when a SPIRV-Reflect shader module is created. It is the
responsibility of the calling program to ensure that the pointer
remains valid and the memory it's pointing to is not freed while
SPIRV-Reflect operations are taking place. Freeing the backing
memory will cause undefined behavior or most likely a crash.
This is flag is intended for cases where the memory overhead of
storing the copied SPIR-V is undesirable.
*/
typedef enum SpvReflectModuleFlagBits {
SPV_REFLECT_MODULE_FLAG_NONE = 0x00000000,
SPV_REFLECT_MODULE_FLAG_NO_COPY = 0x00000001,
} SpvReflectModuleFlagBits;
typedef uint32_t SpvReflectModuleFlags;
/*! @enum SpvReflectTypeFlagBits
*/
typedef enum SpvReflectTypeFlagBits {
SPV_REFLECT_TYPE_FLAG_UNDEFINED = 0x00000000,
SPV_REFLECT_TYPE_FLAG_VOID = 0x00000001,
SPV_REFLECT_TYPE_FLAG_BOOL = 0x00000002,
SPV_REFLECT_TYPE_FLAG_INT = 0x00000004,
SPV_REFLECT_TYPE_FLAG_FLOAT = 0x00000008,
SPV_REFLECT_TYPE_FLAG_VECTOR = 0x00000100,
SPV_REFLECT_TYPE_FLAG_MATRIX = 0x00000200,
SPV_REFLECT_TYPE_FLAG_EXTERNAL_IMAGE = 0x00010000,
SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLER = 0x00020000,
SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLED_IMAGE = 0x00040000,
SPV_REFLECT_TYPE_FLAG_EXTERNAL_BLOCK = 0x00080000,
SPV_REFLECT_TYPE_FLAG_EXTERNAL_ACCELERATION_STRUCTURE = 0x00100000,
SPV_REFLECT_TYPE_FLAG_EXTERNAL_MASK = 0x00FF0000,
SPV_REFLECT_TYPE_FLAG_STRUCT = 0x10000000,
SPV_REFLECT_TYPE_FLAG_ARRAY = 0x20000000,
SPV_REFLECT_TYPE_FLAG_REF = 0x40000000,
} SpvReflectTypeFlagBits;
typedef uint32_t SpvReflectTypeFlags;
/*! @enum SpvReflectDecorationBits
NOTE: HLSL row_major and column_major decorations are reversed
in SPIR-V. Meaning that matrices declrations with row_major
will get reflected as column_major and vice versa. The
row and column decorations get appied during the compilation.
SPIRV-Reflect reads the data as is and does not make any
attempt to correct it to match what's in the source.
The Patch, PerVertex, and PerTask are used for Interface
variables that can have array
*/
typedef enum SpvReflectDecorationFlagBits {
SPV_REFLECT_DECORATION_NONE = 0x00000000,
SPV_REFLECT_DECORATION_BLOCK = 0x00000001,
SPV_REFLECT_DECORATION_BUFFER_BLOCK = 0x00000002,
SPV_REFLECT_DECORATION_ROW_MAJOR = 0x00000004,
SPV_REFLECT_DECORATION_COLUMN_MAJOR = 0x00000008,
SPV_REFLECT_DECORATION_BUILT_IN = 0x00000010,
SPV_REFLECT_DECORATION_NOPERSPECTIVE = 0x00000020,
SPV_REFLECT_DECORATION_FLAT = 0x00000040,
SPV_REFLECT_DECORATION_NON_WRITABLE = 0x00000080,
SPV_REFLECT_DECORATION_RELAXED_PRECISION = 0x00000100,
SPV_REFLECT_DECORATION_NON_READABLE = 0x00000200,
SPV_REFLECT_DECORATION_PATCH = 0x00000400,
SPV_REFLECT_DECORATION_PER_VERTEX = 0x00000800,
SPV_REFLECT_DECORATION_PER_TASK = 0x00001000,
SPV_REFLECT_DECORATION_WEIGHT_TEXTURE = 0x00002000,
SPV_REFLECT_DECORATION_BLOCK_MATCH_TEXTURE = 0x00004000,
} SpvReflectDecorationFlagBits;
typedef uint32_t SpvReflectDecorationFlags;
// Based of SPV_GOOGLE_user_type
typedef enum SpvReflectUserType {
SPV_REFLECT_USER_TYPE_INVALID = 0,
SPV_REFLECT_USER_TYPE_CBUFFER,
SPV_REFLECT_USER_TYPE_TBUFFER,
SPV_REFLECT_USER_TYPE_APPEND_STRUCTURED_BUFFER,
SPV_REFLECT_USER_TYPE_BUFFER,
SPV_REFLECT_USER_TYPE_BYTE_ADDRESS_BUFFER,
SPV_REFLECT_USER_TYPE_CONSTANT_BUFFER,
SPV_REFLECT_USER_TYPE_CONSUME_STRUCTURED_BUFFER,
SPV_REFLECT_USER_TYPE_INPUT_PATCH,
SPV_REFLECT_USER_TYPE_OUTPUT_PATCH,
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BUFFER,
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BYTE_ADDRESS_BUFFER,
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_STRUCTURED_BUFFER,
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D,
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D_ARRAY,
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D,
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D_ARRAY,
SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_3D,
SPV_REFLECT_USER_TYPE_RAYTRACING_ACCELERATION_STRUCTURE,
SPV_REFLECT_USER_TYPE_RW_BUFFER,
SPV_REFLECT_USER_TYPE_RW_BYTE_ADDRESS_BUFFER,
SPV_REFLECT_USER_TYPE_RW_STRUCTURED_BUFFER,
SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D,
SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D_ARRAY,
SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D,
SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D_ARRAY,
SPV_REFLECT_USER_TYPE_RW_TEXTURE_3D,
SPV_REFLECT_USER_TYPE_STRUCTURED_BUFFER,
SPV_REFLECT_USER_TYPE_SUBPASS_INPUT,
SPV_REFLECT_USER_TYPE_SUBPASS_INPUT_MS,
SPV_REFLECT_USER_TYPE_TEXTURE_1D,
SPV_REFLECT_USER_TYPE_TEXTURE_1D_ARRAY,
SPV_REFLECT_USER_TYPE_TEXTURE_2D,
SPV_REFLECT_USER_TYPE_TEXTURE_2D_ARRAY,
SPV_REFLECT_USER_TYPE_TEXTURE_2DMS,
SPV_REFLECT_USER_TYPE_TEXTURE_2DMS_ARRAY,
SPV_REFLECT_USER_TYPE_TEXTURE_3D,
SPV_REFLECT_USER_TYPE_TEXTURE_BUFFER,
SPV_REFLECT_USER_TYPE_TEXTURE_CUBE,
SPV_REFLECT_USER_TYPE_TEXTURE_CUBE_ARRAY,
} SpvReflectUserType;
/*! @enum SpvReflectResourceType
*/
typedef enum SpvReflectResourceType {
SPV_REFLECT_RESOURCE_FLAG_UNDEFINED = 0x00000000,
SPV_REFLECT_RESOURCE_FLAG_SAMPLER = 0x00000001,
SPV_REFLECT_RESOURCE_FLAG_CBV = 0x00000002,
SPV_REFLECT_RESOURCE_FLAG_SRV = 0x00000004,
SPV_REFLECT_RESOURCE_FLAG_UAV = 0x00000008,
} SpvReflectResourceType;
/*! @enum SpvReflectFormat
*/
typedef enum SpvReflectFormat {
SPV_REFLECT_FORMAT_UNDEFINED = 0, // = VK_FORMAT_UNDEFINED
SPV_REFLECT_FORMAT_R16_UINT = 74, // = VK_FORMAT_R16_UINT
SPV_REFLECT_FORMAT_R16_SINT = 75, // = VK_FORMAT_R16_SINT
SPV_REFLECT_FORMAT_R16_SFLOAT = 76, // = VK_FORMAT_R16_SFLOAT
SPV_REFLECT_FORMAT_R16G16_UINT = 81, // = VK_FORMAT_R16G16_UINT
SPV_REFLECT_FORMAT_R16G16_SINT = 82, // = VK_FORMAT_R16G16_SINT
SPV_REFLECT_FORMAT_R16G16_SFLOAT = 83, // = VK_FORMAT_R16G16_SFLOAT
SPV_REFLECT_FORMAT_R16G16B16_UINT = 88, // = VK_FORMAT_R16G16B16_UINT
SPV_REFLECT_FORMAT_R16G16B16_SINT = 89, // = VK_FORMAT_R16G16B16_SINT
SPV_REFLECT_FORMAT_R16G16B16_SFLOAT = 90, // = VK_FORMAT_R16G16B16_SFLOAT
SPV_REFLECT_FORMAT_R16G16B16A16_UINT = 95, // = VK_FORMAT_R16G16B16A16_UINT
SPV_REFLECT_FORMAT_R16G16B16A16_SINT = 96, // = VK_FORMAT_R16G16B16A16_SINT
SPV_REFLECT_FORMAT_R16G16B16A16_SFLOAT = 97, // = VK_FORMAT_R16G16B16A16_SFLOAT
SPV_REFLECT_FORMAT_R32_UINT = 98, // = VK_FORMAT_R32_UINT
SPV_REFLECT_FORMAT_R32_SINT = 99, // = VK_FORMAT_R32_SINT
SPV_REFLECT_FORMAT_R32_SFLOAT = 100, // = VK_FORMAT_R32_SFLOAT
SPV_REFLECT_FORMAT_R32G32_UINT = 101, // = VK_FORMAT_R32G32_UINT
SPV_REFLECT_FORMAT_R32G32_SINT = 102, // = VK_FORMAT_R32G32_SINT
SPV_REFLECT_FORMAT_R32G32_SFLOAT = 103, // = VK_FORMAT_R32G32_SFLOAT
SPV_REFLECT_FORMAT_R32G32B32_UINT = 104, // = VK_FORMAT_R32G32B32_UINT
SPV_REFLECT_FORMAT_R32G32B32_SINT = 105, // = VK_FORMAT_R32G32B32_SINT
SPV_REFLECT_FORMAT_R32G32B32_SFLOAT = 106, // = VK_FORMAT_R32G32B32_SFLOAT
SPV_REFLECT_FORMAT_R32G32B32A32_UINT = 107, // = VK_FORMAT_R32G32B32A32_UINT
SPV_REFLECT_FORMAT_R32G32B32A32_SINT = 108, // = VK_FORMAT_R32G32B32A32_SINT
SPV_REFLECT_FORMAT_R32G32B32A32_SFLOAT = 109, // = VK_FORMAT_R32G32B32A32_SFLOAT
SPV_REFLECT_FORMAT_R64_UINT = 110, // = VK_FORMAT_R64_UINT
SPV_REFLECT_FORMAT_R64_SINT = 111, // = VK_FORMAT_R64_SINT
SPV_REFLECT_FORMAT_R64_SFLOAT = 112, // = VK_FORMAT_R64_SFLOAT
SPV_REFLECT_FORMAT_R64G64_UINT = 113, // = VK_FORMAT_R64G64_UINT
SPV_REFLECT_FORMAT_R64G64_SINT = 114, // = VK_FORMAT_R64G64_SINT
SPV_REFLECT_FORMAT_R64G64_SFLOAT = 115, // = VK_FORMAT_R64G64_SFLOAT
SPV_REFLECT_FORMAT_R64G64B64_UINT = 116, // = VK_FORMAT_R64G64B64_UINT
SPV_REFLECT_FORMAT_R64G64B64_SINT = 117, // = VK_FORMAT_R64G64B64_SINT
SPV_REFLECT_FORMAT_R64G64B64_SFLOAT = 118, // = VK_FORMAT_R64G64B64_SFLOAT
SPV_REFLECT_FORMAT_R64G64B64A64_UINT = 119, // = VK_FORMAT_R64G64B64A64_UINT
SPV_REFLECT_FORMAT_R64G64B64A64_SINT = 120, // = VK_FORMAT_R64G64B64A64_SINT
SPV_REFLECT_FORMAT_R64G64B64A64_SFLOAT = 121, // = VK_FORMAT_R64G64B64A64_SFLOAT
} SpvReflectFormat;
/*! @enum SpvReflectVariableFlagBits
*/
enum SpvReflectVariableFlagBits{
SPV_REFLECT_VARIABLE_FLAGS_NONE = 0x00000000,
SPV_REFLECT_VARIABLE_FLAGS_UNUSED = 0x00000001,
// If variable points to a copy of the PhysicalStorageBuffer struct
SPV_REFLECT_VARIABLE_FLAGS_PHYSICAL_POINTER_COPY = 0x00000002,
};
typedef uint32_t SpvReflectVariableFlags;
/*! @enum SpvReflectDescriptorType
*/
typedef enum SpvReflectDescriptorType {
SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLER = 0, // = VK_DESCRIPTOR_TYPE_SAMPLER
SPV_REFLECT_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, // = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, // = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, // = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, // = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER
SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, // = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, // = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, // = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, // = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, // = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
SPV_REFLECT_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, // = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
SPV_REFLECT_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000 // = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR
} SpvReflectDescriptorType;
/*! @enum SpvReflectShaderStageFlagBits
*/
typedef enum SpvReflectShaderStageFlagBits {
SPV_REFLECT_SHADER_STAGE_VERTEX_BIT = 0x00000001, // = VK_SHADER_STAGE_VERTEX_BIT
SPV_REFLECT_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, // = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT
SPV_REFLECT_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, // = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT
SPV_REFLECT_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, // = VK_SHADER_STAGE_GEOMETRY_BIT
SPV_REFLECT_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, // = VK_SHADER_STAGE_FRAGMENT_BIT
SPV_REFLECT_SHADER_STAGE_COMPUTE_BIT = 0x00000020, // = VK_SHADER_STAGE_COMPUTE_BIT
SPV_REFLECT_SHADER_STAGE_TASK_BIT_NV = 0x00000040, // = VK_SHADER_STAGE_TASK_BIT_NV
SPV_REFLECT_SHADER_STAGE_TASK_BIT_EXT = SPV_REFLECT_SHADER_STAGE_TASK_BIT_NV, // = VK_SHADER_STAGE_CALLABLE_BIT_EXT
SPV_REFLECT_SHADER_STAGE_MESH_BIT_NV = 0x00000080, // = VK_SHADER_STAGE_MESH_BIT_NV
SPV_REFLECT_SHADER_STAGE_MESH_BIT_EXT = SPV_REFLECT_SHADER_STAGE_MESH_BIT_NV, // = VK_SHADER_STAGE_CALLABLE_BIT_EXT
SPV_REFLECT_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100, // = VK_SHADER_STAGE_RAYGEN_BIT_KHR
SPV_REFLECT_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200, // = VK_SHADER_STAGE_ANY_HIT_BIT_KHR
SPV_REFLECT_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400, // = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR
SPV_REFLECT_SHADER_STAGE_MISS_BIT_KHR = 0x00000800, // = VK_SHADER_STAGE_MISS_BIT_KHR
SPV_REFLECT_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000, // = VK_SHADER_STAGE_INTERSECTION_BIT_KHR
SPV_REFLECT_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000, // = VK_SHADER_STAGE_CALLABLE_BIT_KHR
} SpvReflectShaderStageFlagBits;
/*! @enum SpvReflectGenerator
*/
typedef enum SpvReflectGenerator {
SPV_REFLECT_GENERATOR_KHRONOS_LLVM_SPIRV_TRANSLATOR = 6,
SPV_REFLECT_GENERATOR_KHRONOS_SPIRV_TOOLS_ASSEMBLER = 7,
SPV_REFLECT_GENERATOR_KHRONOS_GLSLANG_REFERENCE_FRONT_END = 8,
SPV_REFLECT_GENERATOR_GOOGLE_SHADERC_OVER_GLSLANG = 13,
SPV_REFLECT_GENERATOR_GOOGLE_SPIREGG = 14,
SPV_REFLECT_GENERATOR_GOOGLE_RSPIRV = 15,
SPV_REFLECT_GENERATOR_X_LEGEND_MESA_MESAIR_SPIRV_TRANSLATOR = 16,
SPV_REFLECT_GENERATOR_KHRONOS_SPIRV_TOOLS_LINKER = 17,
SPV_REFLECT_GENERATOR_WINE_VKD3D_SHADER_COMPILER = 18,
SPV_REFLECT_GENERATOR_CLAY_CLAY_SHADER_COMPILER = 19,
} SpvReflectGenerator;
enum {
SPV_REFLECT_MAX_ARRAY_DIMS = 32,
SPV_REFLECT_MAX_DESCRIPTOR_SETS = 64,
};
enum {
SPV_REFLECT_BINDING_NUMBER_DONT_CHANGE = ~0,
SPV_REFLECT_SET_NUMBER_DONT_CHANGE = ~0
};
typedef struct SpvReflectNumericTraits {
struct Scalar {
uint32_t width;
uint32_t signedness;
} scalar;
struct Vector {
uint32_t component_count;
} vector;
struct Matrix {
uint32_t column_count;
uint32_t row_count;
uint32_t stride; // Measured in bytes
} matrix;
} SpvReflectNumericTraits;
typedef struct SpvReflectImageTraits {
SpvDim dim;
uint32_t depth;
uint32_t arrayed;
uint32_t ms; // 0: single-sampled; 1: multisampled
uint32_t sampled;
SpvImageFormat image_format;
} SpvReflectImageTraits;
typedef enum SpvReflectArrayDimType {
SPV_REFLECT_ARRAY_DIM_RUNTIME = 0, // OpTypeRuntimeArray
} SpvReflectArrayDimType;
typedef struct SpvReflectArrayTraits {
uint32_t dims_count;
// Each entry is either:
// - specialization constant dimension
// - OpTypeRuntimeArray
// - the array length otherwise
uint32_t dims[SPV_REFLECT_MAX_ARRAY_DIMS];
// Stores Ids for dimensions that are specialization constants
uint32_t spec_constant_op_ids[SPV_REFLECT_MAX_ARRAY_DIMS];
uint32_t stride; // Measured in bytes
} SpvReflectArrayTraits;
typedef struct SpvReflectBindingArrayTraits {
uint32_t dims_count;
uint32_t dims[SPV_REFLECT_MAX_ARRAY_DIMS];
} SpvReflectBindingArrayTraits;
/*! @struct SpvReflectTypeDescription
@brief Information about an OpType* instruction
*/
typedef struct SpvReflectTypeDescription {
uint32_t id;
SpvOp op;
const char* type_name;
// Non-NULL if type is member of a struct
const char* struct_member_name;
SpvStorageClass storage_class;
SpvReflectTypeFlags type_flags;
SpvReflectDecorationFlags decoration_flags;
struct Traits {
SpvReflectNumericTraits numeric;
SpvReflectImageTraits image;
SpvReflectArrayTraits array;
} traits;
// If underlying type is a struct (ex. array of structs)
// this gives access to the OpTypeStruct
struct SpvReflectTypeDescription* struct_type_description;
// Some pointers to SpvReflectTypeDescription are really
// just copies of another reference to the same OpType
uint32_t copied;
// @deprecated use struct_type_description instead
uint32_t member_count;
// @deprecated use struct_type_description instead
struct SpvReflectTypeDescription* members;
} SpvReflectTypeDescription;
/*! @struct SpvReflectInterfaceVariable
@brief The OpVariable that is either an Input or Output to the module
*/
typedef struct SpvReflectInterfaceVariable {
uint32_t spirv_id;
const char* name;
uint32_t location;
uint32_t component;
SpvStorageClass storage_class;
const char* semantic;
SpvReflectDecorationFlags decoration_flags;
SpvBuiltIn built_in;
SpvReflectNumericTraits numeric;
SpvReflectArrayTraits array;
uint32_t member_count;
struct SpvReflectInterfaceVariable* members;
SpvReflectFormat format;
// NOTE: SPIR-V shares type references for variables
// that have the same underlying type. This means
// that the same type name will appear for multiple
// variables.
SpvReflectTypeDescription* type_description;
struct {
uint32_t location;
} word_offset;
} SpvReflectInterfaceVariable;
/*! @struct SpvReflectBlockVariable
*/
typedef struct SpvReflectBlockVariable {
uint32_t spirv_id;
const char* name;
// For Push Constants, this is the lowest offset of all memebers
uint32_t offset; // Measured in bytes
uint32_t absolute_offset; // Measured in bytes
uint32_t size; // Measured in bytes
uint32_t padded_size; // Measured in bytes
SpvReflectDecorationFlags decoration_flags;
SpvReflectNumericTraits numeric;
SpvReflectArrayTraits array;
SpvReflectVariableFlags flags;
uint32_t member_count;
struct SpvReflectBlockVariable* members;
SpvReflectTypeDescription* type_description;
struct {
uint32_t offset;
} word_offset;
} SpvReflectBlockVariable;
/*! @struct SpvReflectDescriptorBinding
*/
typedef struct SpvReflectDescriptorBinding {
uint32_t spirv_id;
const char* name;
uint32_t binding;
uint32_t input_attachment_index;
uint32_t set;
SpvReflectDescriptorType descriptor_type;
SpvReflectResourceType resource_type;
SpvReflectImageTraits image;
SpvReflectBlockVariable block;
SpvReflectBindingArrayTraits array;
uint32_t count;
uint32_t accessed;
uint32_t uav_counter_id;
struct SpvReflectDescriptorBinding* uav_counter_binding;
uint32_t byte_address_buffer_offset_count;
uint32_t* byte_address_buffer_offsets;
SpvReflectTypeDescription* type_description;
struct {
uint32_t binding;
uint32_t set;
} word_offset;
SpvReflectDecorationFlags decoration_flags;
// Requires SPV_GOOGLE_user_type
SpvReflectUserType user_type;
} SpvReflectDescriptorBinding;
/*! @struct SpvReflectDescriptorSet
*/
typedef struct SpvReflectDescriptorSet {
uint32_t set;
uint32_t binding_count;
SpvReflectDescriptorBinding** bindings;
} SpvReflectDescriptorSet;
typedef enum SpvReflectExecutionModeValue {
SPV_REFLECT_EXECUTION_MODE_SPEC_CONSTANT = 0xFFFFFFFF // specialization constant
} SpvReflectExecutionModeValue;
/*! @struct SpvReflectEntryPoint
*/
typedef struct SpvReflectEntryPoint {
const char* name;
uint32_t id;
SpvExecutionModel spirv_execution_model;
SpvReflectShaderStageFlagBits shader_stage;
uint32_t input_variable_count;
SpvReflectInterfaceVariable** input_variables;
uint32_t output_variable_count;
SpvReflectInterfaceVariable** output_variables;
uint32_t interface_variable_count;
SpvReflectInterfaceVariable* interface_variables;
uint32_t descriptor_set_count;
SpvReflectDescriptorSet* descriptor_sets;
uint32_t used_uniform_count;
uint32_t* used_uniforms;
uint32_t used_push_constant_count;
uint32_t* used_push_constants;
uint32_t execution_mode_count;
SpvExecutionMode* execution_modes;
struct LocalSize {
uint32_t x;
uint32_t y;
uint32_t z;
} local_size;
uint32_t invocations; // valid for geometry
uint32_t output_vertices; // valid for geometry, tesselation
} SpvReflectEntryPoint;
/*! @struct SpvReflectCapability
*/
typedef struct SpvReflectCapability {
SpvCapability value;
uint32_t word_offset;
} SpvReflectCapability;
// -- GODOT begin --
/*! @enum SpvReflectSpecializationConstantType
*/
typedef enum SpvReflectSpecializationConstantType {
SPV_REFLECT_SPECIALIZATION_CONSTANT_BOOL = 0,
SPV_REFLECT_SPECIALIZATION_CONSTANT_INT = 1,
SPV_REFLECT_SPECIALIZATION_CONSTANT_FLOAT = 2,
} SpvReflectSpecializationConstantType;
// -- GODOT end --
/*! @struct SpvReflectSpecId
*/
typedef struct SpvReflectSpecializationConstant {
uint32_t spirv_id;
uint32_t constant_id;
const char* name;
// -- GODOT begin --
SpvReflectSpecializationConstantType constant_type;
union {
float float_value;
uint32_t int_bool_value;
} default_value;
// -- GODOT end --
} SpvReflectSpecializationConstant;
/*! @struct SpvReflectShaderModule
*/
typedef struct SpvReflectShaderModule {
SpvReflectGenerator generator;
const char* entry_point_name;
uint32_t entry_point_id;
uint32_t entry_point_count;
SpvReflectEntryPoint* entry_points;
SpvSourceLanguage source_language;
uint32_t source_language_version;
const char* source_file;
const char* source_source;
uint32_t capability_count;
SpvReflectCapability* capabilities;
SpvExecutionModel spirv_execution_model; // Uses value(s) from first entry point
SpvReflectShaderStageFlagBits shader_stage; // Uses value(s) from first entry point
uint32_t descriptor_binding_count; // Uses value(s) from first entry point
SpvReflectDescriptorBinding* descriptor_bindings; // Uses value(s) from first entry point
uint32_t descriptor_set_count; // Uses value(s) from first entry point
SpvReflectDescriptorSet descriptor_sets[SPV_REFLECT_MAX_DESCRIPTOR_SETS]; // Uses value(s) from first entry point
uint32_t input_variable_count; // Uses value(s) from first entry point
SpvReflectInterfaceVariable** input_variables; // Uses value(s) from first entry point
uint32_t output_variable_count; // Uses value(s) from first entry point
SpvReflectInterfaceVariable** output_variables; // Uses value(s) from first entry point
uint32_t interface_variable_count; // Uses value(s) from first entry point
SpvReflectInterfaceVariable* interface_variables; // Uses value(s) from first entry point
uint32_t push_constant_block_count; // Uses value(s) from first entry point
SpvReflectBlockVariable* push_constant_blocks; // Uses value(s) from first entry point
uint32_t spec_constant_count; // Uses value(s) from first entry point
SpvReflectSpecializationConstant* spec_constants; // Uses value(s) from first entry point
struct Internal {
SpvReflectModuleFlags module_flags;
size_t spirv_size;
uint32_t* spirv_code;
uint32_t spirv_word_count;
size_t type_description_count;
SpvReflectTypeDescription* type_descriptions;
} * _internal;
} SpvReflectShaderModule;
#if defined(__cplusplus)
extern "C" {
#endif
/*! @fn spvReflectCreateShaderModule
@param size Size in bytes of SPIR-V code.
@param p_code Pointer to SPIR-V code.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@return SPV_REFLECT_RESULT_SUCCESS on success.
*/
SpvReflectResult spvReflectCreateShaderModule(
size_t size,
const void* p_code,
SpvReflectShaderModule* p_module
);
/*! @fn spvReflectCreateShaderModule2
@param flags Flags for module creations.
@param size Size in bytes of SPIR-V code.
@param p_code Pointer to SPIR-V code.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@return SPV_REFLECT_RESULT_SUCCESS on success.
*/
SpvReflectResult spvReflectCreateShaderModule2(
SpvReflectModuleFlags flags,
size_t size,
const void* p_code,
SpvReflectShaderModule* p_module
);
SPV_REFLECT_DEPRECATED("renamed to spvReflectCreateShaderModule")
SpvReflectResult spvReflectGetShaderModule(
size_t size,
const void* p_code,
SpvReflectShaderModule* p_module
);
/*! @fn spvReflectDestroyShaderModule
@param p_module Pointer to an instance of SpvReflectShaderModule.
*/
void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module);
/*! @fn spvReflectGetCodeSize
@param p_module Pointer to an instance of SpvReflectShaderModule.
@return Returns the size of the SPIR-V in bytes
*/
uint32_t spvReflectGetCodeSize(const SpvReflectShaderModule* p_module);
/*! @fn spvReflectGetCode
@param p_module Pointer to an instance of SpvReflectShaderModule.
@return Returns a const pointer to the compiled SPIR-V bytecode.
*/
const uint32_t* spvReflectGetCode(const SpvReflectShaderModule* p_module);
/*! @fn spvReflectGetEntryPoint
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param entry_point Name of the requested entry point.
@return Returns a const pointer to the requested entry point,
or NULL if it's not found.
*/
const SpvReflectEntryPoint* spvReflectGetEntryPoint(
const SpvReflectShaderModule* p_module,
const char* entry_point
);
/*! @fn spvReflectEnumerateDescriptorBindings
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param p_count If pp_bindings is NULL, the module's descriptor binding
count (across all descriptor sets) will be stored here.
If pp_bindings is not NULL, *p_count must contain the
module's descriptor binding count.
@param pp_bindings If NULL, the module's total descriptor binding count
will be written to *p_count.
If non-NULL, pp_bindings must point to an array with
*p_count entries, where pointers to the module's
descriptor bindings will be written. The caller must not
free the binding pointers written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateDescriptorBindings(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectDescriptorBinding** pp_bindings
);
/*! @fn spvReflectEnumerateEntryPointDescriptorBindings
@brief Creates a listing of all descriptor bindings that are used in the
static call tree of the given entry point.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param entry_point The name of the entry point to get the descriptor bindings for.
@param p_count If pp_bindings is NULL, the entry point's descriptor binding
count (across all descriptor sets) will be stored here.
If pp_bindings is not NULL, *p_count must contain the
entry points's descriptor binding count.
@param pp_bindings If NULL, the entry point's total descriptor binding count
will be written to *p_count.
If non-NULL, pp_bindings must point to an array with
*p_count entries, where pointers to the entry point's
descriptor bindings will be written. The caller must not
free the binding pointers written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateEntryPointDescriptorBindings(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectDescriptorBinding** pp_bindings
);
/*! @fn spvReflectEnumerateDescriptorSets
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param p_count If pp_sets is NULL, the module's descriptor set
count will be stored here.
If pp_sets is not NULL, *p_count must contain the
module's descriptor set count.
@param pp_sets If NULL, the module's total descriptor set count
will be written to *p_count.
If non-NULL, pp_sets must point to an array with
*p_count entries, where pointers to the module's
descriptor sets will be written. The caller must not
free the descriptor set pointers written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateDescriptorSets(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectDescriptorSet** pp_sets
);
/*! @fn spvReflectEnumerateEntryPointDescriptorSets
@brief Creates a listing of all descriptor sets and their bindings that are
used in the static call tree of a given entry point.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param entry_point The name of the entry point to get the descriptor bindings for.
@param p_count If pp_sets is NULL, the module's descriptor set
count will be stored here.
If pp_sets is not NULL, *p_count must contain the
module's descriptor set count.
@param pp_sets If NULL, the module's total descriptor set count
will be written to *p_count.
If non-NULL, pp_sets must point to an array with
*p_count entries, where pointers to the module's
descriptor sets will be written. The caller must not
free the descriptor set pointers written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateEntryPointDescriptorSets(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectDescriptorSet** pp_sets
);
/*! @fn spvReflectEnumerateInterfaceVariables
@brief If the module contains multiple entry points, this will only get
the interface variables for the first one.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param p_count If pp_variables is NULL, the module's interface variable
count will be stored here.
If pp_variables is not NULL, *p_count must contain
the module's interface variable count.
@param pp_variables If NULL, the module's interface variable count will be
written to *p_count.
If non-NULL, pp_variables must point to an array with
*p_count entries, where pointers to the module's
interface variables will be written. The caller must not
free the interface variables written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateInterfaceVariables(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
);
/*! @fn spvReflectEnumerateEntryPointInterfaceVariables
@brief Enumerate the interface variables for a given entry point.
@param entry_point The name of the entry point to get the interface variables for.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param p_count If pp_variables is NULL, the entry point's interface variable
count will be stored here.
If pp_variables is not NULL, *p_count must contain
the entry point's interface variable count.
@param pp_variables If NULL, the entry point's interface variable count will be
written to *p_count.
If non-NULL, pp_variables must point to an array with
*p_count entries, where pointers to the entry point's
interface variables will be written. The caller must not
free the interface variables written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateEntryPointInterfaceVariables(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
);
/*! @fn spvReflectEnumerateInputVariables
@brief If the module contains multiple entry points, this will only get
the input variables for the first one.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param p_count If pp_variables is NULL, the module's input variable
count will be stored here.
If pp_variables is not NULL, *p_count must contain
the module's input variable count.
@param pp_variables If NULL, the module's input variable count will be
written to *p_count.
If non-NULL, pp_variables must point to an array with
*p_count entries, where pointers to the module's
input variables will be written. The caller must not
free the interface variables written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateInputVariables(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
);
/*! @fn spvReflectEnumerateEntryPointInputVariables
@brief Enumerate the input variables for a given entry point.
@param entry_point The name of the entry point to get the input variables for.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param p_count If pp_variables is NULL, the entry point's input variable
count will be stored here.
If pp_variables is not NULL, *p_count must contain
the entry point's input variable count.
@param pp_variables If NULL, the entry point's input variable count will be
written to *p_count.
If non-NULL, pp_variables must point to an array with
*p_count entries, where pointers to the entry point's
input variables will be written. The caller must not
free the interface variables written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateEntryPointInputVariables(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
);
/*! @fn spvReflectEnumerateOutputVariables
@brief Note: If the module contains multiple entry points, this will only get
the output variables for the first one.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param p_count If pp_variables is NULL, the module's output variable
count will be stored here.
If pp_variables is not NULL, *p_count must contain
the module's output variable count.
@param pp_variables If NULL, the module's output variable count will be
written to *p_count.
If non-NULL, pp_variables must point to an array with
*p_count entries, where pointers to the module's
output variables will be written. The caller must not
free the interface variables written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateOutputVariables(
const SpvReflectShaderModule* p_module,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
);
/*! @fn spvReflectEnumerateEntryPointOutputVariables
@brief Enumerate the output variables for a given entry point.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param entry_point The name of the entry point to get the output variables for.
@param p_count If pp_variables is NULL, the entry point's output variable
count will be stored here.
If pp_variables is not NULL, *p_count must contain
the entry point's output variable count.
@param pp_variables If NULL, the entry point's output variable count will be
written to *p_count.
If non-NULL, pp_variables must point to an array with
*p_count entries, where pointers to the entry point's
output variables will be written. The caller must not
free the interface variables written to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumerateEntryPointOutputVariables(
const SpvReflectShaderModule* p_module,
const char* entry_point,
uint32_t* p_count,
SpvReflectInterfaceVariable** pp_variables
);
/*! @fn spvReflectEnumeratePushConstantBlocks
@brief Note: If the module contains multiple entry points, this will only get
the push constant blocks for the first one.
@param p_module Pointer to an instance of SpvReflectShaderModule.
@param p_count If pp_blocks is NULL, the module's push constant
block count will be stored here.
If pp_blocks is not NULL, *p_count must
contain the module's push constant block count.
@param pp_blocks If NULL, the module's push constant block count
will be written to *p_count.
If non-NULL, pp_blocks must point to an
array with *p_count entries, where pointers to
the module's push constant blocks will be written.
The caller must not free the block variables written
to this array.
@return If successful, returns SPV_REFLECT_RESULT_SUCCESS.
Otherwise, the error code indicates the cause of the
failure.
*/
SpvReflectResult spvReflectEnumeratePushConstantBlocks(