1 #ifndef VULKAN_CORE_H_
2 #define VULKAN_CORE_H_ 1
3 
4 /*
5 ** Copyright 2015-2021 The Khronos Group Inc.
6 **
7 ** SPDX-License-Identifier: Apache-2.0
8 */
9 
10 /*
11 ** This header is generated from the Khronos Vulkan XML API Registry.
12 **
13 */
14 
15 
16 #ifdef __cplusplus
17 extern "C" {
18 #endif
19 
20 
21 
22 #define VK_VERSION_1_0 1
23 #include "vk_platform.h"
24 
25 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
26 
27 
28 #ifndef VK_USE_64_BIT_PTR_DEFINES
29     #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
30         #define VK_USE_64_BIT_PTR_DEFINES 1
31     #else
32         #define VK_USE_64_BIT_PTR_DEFINES 0
33     #endif
34 #endif
35 
36 
37 #ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
38     #if (VK_USE_64_BIT_PTR_DEFINES==1)
39         #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L))
40             #define VK_NULL_HANDLE nullptr
41         #else
42             #define VK_NULL_HANDLE ((void*)0)
43         #endif
44     #else
45         #define VK_NULL_HANDLE 0ULL
46     #endif
47 #endif
48 #ifndef VK_NULL_HANDLE
49     #define VK_NULL_HANDLE 0
50 #endif
51 
52 
53 #ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
54     #if (VK_USE_64_BIT_PTR_DEFINES==1)
55         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
56     #else
57         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
58     #endif
59 #endif
60 
61 // DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead.
62 #define VK_MAKE_VERSION(major, minor, patch) \
63     ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
64 
65 // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
66 //#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
67 
68 #define VK_MAKE_API_VERSION(variant, major, minor, patch) \
69     ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
70 
71 // Vulkan 1.0 version number
72 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
73 
74 // Version of this file
75 #define VK_HEADER_VERSION 182
76 
77 // Complete version of this file
78 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)
79 
80 // DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead.
81 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
82 
83 // DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead.
84 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
85 
86 // DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead.
87 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
88 
89 #define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29)
90 #define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU)
91 #define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
92 #define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
93 typedef uint32_t VkBool32;
94 typedef uint64_t VkDeviceAddress;
95 typedef uint64_t VkDeviceSize;
96 typedef uint32_t VkFlags;
97 typedef uint32_t VkSampleMask;
98 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
99 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
100 VK_DEFINE_HANDLE(VkInstance)
101 VK_DEFINE_HANDLE(VkPhysicalDevice)
102 VK_DEFINE_HANDLE(VkDevice)
103 VK_DEFINE_HANDLE(VkQueue)
104 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
105 VK_DEFINE_HANDLE(VkCommandBuffer)
106 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
107 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
108 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
109 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
110 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
111 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
112 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
113 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
114 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
115 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
116 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
117 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
118 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
119 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
120 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
121 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
122 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
123 #define VK_ATTACHMENT_UNUSED              (~0U)
124 #define VK_FALSE                          0U
125 #define VK_LOD_CLAMP_NONE                 1000.0F
126 #define VK_QUEUE_FAMILY_IGNORED           (~0U)
127 #define VK_REMAINING_ARRAY_LAYERS         (~0U)
128 #define VK_REMAINING_MIP_LEVELS           (~0U)
129 #define VK_SUBPASS_EXTERNAL               (~0U)
130 #define VK_TRUE                           1U
131 #define VK_WHOLE_SIZE                     (~0ULL)
132 #define VK_MAX_MEMORY_TYPES               32U
133 #define VK_MAX_MEMORY_HEAPS               16U
134 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256U
135 #define VK_UUID_SIZE                      16U
136 #define VK_MAX_EXTENSION_NAME_SIZE        256U
137 #define VK_MAX_DESCRIPTION_SIZE           256U
138 
139 typedef enum VkResult {
140     VK_SUCCESS = 0,
141     VK_NOT_READY = 1,
142     VK_TIMEOUT = 2,
143     VK_EVENT_SET = 3,
144     VK_EVENT_RESET = 4,
145     VK_INCOMPLETE = 5,
146     VK_ERROR_OUT_OF_HOST_MEMORY = -1,
147     VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
148     VK_ERROR_INITIALIZATION_FAILED = -3,
149     VK_ERROR_DEVICE_LOST = -4,
150     VK_ERROR_MEMORY_MAP_FAILED = -5,
151     VK_ERROR_LAYER_NOT_PRESENT = -6,
152     VK_ERROR_EXTENSION_NOT_PRESENT = -7,
153     VK_ERROR_FEATURE_NOT_PRESENT = -8,
154     VK_ERROR_INCOMPATIBLE_DRIVER = -9,
155     VK_ERROR_TOO_MANY_OBJECTS = -10,
156     VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
157     VK_ERROR_FRAGMENTED_POOL = -12,
158     VK_ERROR_UNKNOWN = -13,
159     VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,
160     VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
161     VK_ERROR_FRAGMENTATION = -1000161000,
162     VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000,
163     VK_ERROR_SURFACE_LOST_KHR = -1000000000,
164     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
165     VK_SUBOPTIMAL_KHR = 1000001003,
166     VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
167     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
168     VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
169     VK_ERROR_INVALID_SHADER_NV = -1000012000,
170     VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
171     VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
172     VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
173     VK_THREAD_IDLE_KHR = 1000268000,
174     VK_THREAD_DONE_KHR = 1000268001,
175     VK_OPERATION_DEFERRED_KHR = 1000268002,
176     VK_OPERATION_NOT_DEFERRED_KHR = 1000268003,
177     VK_PIPELINE_COMPILE_REQUIRED_EXT = 1000297000,
178     VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
179     VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
180     VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION,
181     VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
182     VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
183     VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED_EXT,
184     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
185 } VkResult;
186 
187 typedef enum VkStructureType {
188     VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
189     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
190     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
191     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
192     VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
193     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
194     VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
195     VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
196     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
197     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
198     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
199     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
200     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
201     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
202     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
203     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
204     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
205     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
206     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
207     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
208     VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
209     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
210     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
211     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
212     VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
213     VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
214     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
215     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
216     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
217     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
218     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
219     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
220     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
221     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
222     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
223     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
224     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
225     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
226     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
227     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
228     VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
229     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
230     VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
231     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
232     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
233     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
234     VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
235     VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
236     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
237     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000,
238     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000,
239     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001,
240     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000,
241     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000,
242     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001,
243     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000,
244     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003,
245     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,
246     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005,
247     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006,
248     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,
249     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014,
250     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,
251     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001,
252     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000,
253     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001,
254     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,
255     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003,
256     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004,
257     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000,
258     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001,
259     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002,
260     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003,
261     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004,
262     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005,
263     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006,
264     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007,
265     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008,
266     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000,
267     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001,
268     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002,
269     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
270     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000,
271     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001,
272     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002,
273     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000,
274     VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000,
275     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001,
276     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,
277     VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003,
278     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000,
279     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001,
280     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002,
281     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003,
282     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
283     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005,
284     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000,
285     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,
286     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001,
287     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002,
288     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003,
289     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004,
290     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,
291     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001,
292     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002,
293     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,
294     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001,
295     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000,
296     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000,
297     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,
298     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001,
299     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,
300     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001,
301     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000,
302     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49,
303     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50,
304     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51,
305     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52,
306     VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000,
307     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000,
308     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001,
309     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002,
310     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003,
311     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004,
312     VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005,
313     VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006,
314     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000,
315     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000,
316     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000,
317     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000,
318     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000,
319     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000,
320     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001,
321     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002,
322     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003,
323     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004,
324     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000,
325     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001,
326     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000,
327     VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000,
328     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000,
329     VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001,
330     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000,
331     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000,
332     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001,
333     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002,
334     VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003,
335     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000,
336     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000,
337     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000,
338     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001,
339     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002,
340     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000,
341     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000,
342     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001,
343     VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002,
344     VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003,
345     VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004,
346     VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005,
347     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000,
348     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001,
349     VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002,
350     VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003,
351     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004,
352     VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
353     VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
354     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007,
355     VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008,
356     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009,
357     VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010,
358     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011,
359     VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012,
360     VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
361     VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
362     VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
363     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
364     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
365     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
366     VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
367     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
368     VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
369     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
370     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
371     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
372     VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
373 #ifdef VK_ENABLE_BETA_EXTENSIONS
374     VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR = 1000023000,
375 #endif
376 #ifdef VK_ENABLE_BETA_EXTENSIONS
377     VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001,
378 #endif
379 #ifdef VK_ENABLE_BETA_EXTENSIONS
380     VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR = 1000023002,
381 #endif
382 #ifdef VK_ENABLE_BETA_EXTENSIONS
383     VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR = 1000023003,
384 #endif
385 #ifdef VK_ENABLE_BETA_EXTENSIONS
386     VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR = 1000023004,
387 #endif
388 #ifdef VK_ENABLE_BETA_EXTENSIONS
389     VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005,
390 #endif
391 #ifdef VK_ENABLE_BETA_EXTENSIONS
392     VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006,
393 #endif
394 #ifdef VK_ENABLE_BETA_EXTENSIONS
395     VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007,
396 #endif
397 #ifdef VK_ENABLE_BETA_EXTENSIONS
398     VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008,
399 #endif
400 #ifdef VK_ENABLE_BETA_EXTENSIONS
401     VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009,
402 #endif
403 #ifdef VK_ENABLE_BETA_EXTENSIONS
404     VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010,
405 #endif
406 #ifdef VK_ENABLE_BETA_EXTENSIONS
407     VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR = 1000023011,
408 #endif
409 #ifdef VK_ENABLE_BETA_EXTENSIONS
410     VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000023012,
411 #endif
412 #ifdef VK_ENABLE_BETA_EXTENSIONS
413     VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR = 1000023013,
414 #endif
415 #ifdef VK_ENABLE_BETA_EXTENSIONS
416     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014,
417 #endif
418 #ifdef VK_ENABLE_BETA_EXTENSIONS
419     VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015,
420 #endif
421 #ifdef VK_ENABLE_BETA_EXTENSIONS
422     VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000,
423 #endif
424     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
425     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
426     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
427     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000,
428     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001,
429     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002,
430     VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000,
431     VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001,
432     VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002,
433     VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,
434     VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001,
435 #ifdef VK_ENABLE_BETA_EXTENSIONS
436     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000,
437 #endif
438 #ifdef VK_ENABLE_BETA_EXTENSIONS
439     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT = 1000038001,
440 #endif
441 #ifdef VK_ENABLE_BETA_EXTENSIONS
442     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038002,
443 #endif
444 #ifdef VK_ENABLE_BETA_EXTENSIONS
445     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038003,
446 #endif
447 #ifdef VK_ENABLE_BETA_EXTENSIONS
448     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038004,
449 #endif
450 #ifdef VK_ENABLE_BETA_EXTENSIONS
451     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038005,
452 #endif
453 #ifdef VK_ENABLE_BETA_EXTENSIONS
454     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT = 1000038006,
455 #endif
456 #ifdef VK_ENABLE_BETA_EXTENSIONS
457     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT = 1000038007,
458 #endif
459 #ifdef VK_ENABLE_BETA_EXTENSIONS
460     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT = 1000038008,
461 #endif
462 #ifdef VK_ENABLE_BETA_EXTENSIONS
463     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT = 1000040000,
464 #endif
465 #ifdef VK_ENABLE_BETA_EXTENSIONS
466     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT = 1000040001,
467 #endif
468 #ifdef VK_ENABLE_BETA_EXTENSIONS
469     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT = 1000040002,
470 #endif
471 #ifdef VK_ENABLE_BETA_EXTENSIONS
472     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT = 1000040003,
473 #endif
474 #ifdef VK_ENABLE_BETA_EXTENSIONS
475     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT = 1000040004,
476 #endif
477 #ifdef VK_ENABLE_BETA_EXTENSIONS
478     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000040005,
479 #endif
480 #ifdef VK_ENABLE_BETA_EXTENSIONS
481     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000040006,
482 #endif
483 #ifdef VK_ENABLE_BETA_EXTENSIONS
484     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT = 1000040007,
485 #endif
486     VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
487     VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000,
488     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000,
489     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
490     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
491     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
492     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
493     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
494     VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
495     VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
496     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000,
497     VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,
498     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,
499     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
500     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
501     VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
502     VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
503     VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
504     VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
505     VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
506     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
507     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
508     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
509     VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
510     VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
511     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
512     VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
513     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
514     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
515     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
516     VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
517     VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
518     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
519     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
520     VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
521     VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
522     VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
523     VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
524     VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
525     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
526     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
527     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
528     VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
529     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
530     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
531     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
532     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
533     VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
534     VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
535     VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
536     VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
537     VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
538     VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
539     VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
540     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,
541     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,
542     VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,
543     VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,
544     VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,
545     VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005,
546     VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,
547     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
548     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
549     VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
550     VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000,
551     VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001,
552     VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002,
553     VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003,
554     VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004,
555     VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
556     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
557     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,
558     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,
559     VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002,
560     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,
561     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004,
562     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000,
563     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001,
564     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
565     VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003,
566     VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,
567     VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005,
568     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000,
569     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001,
570     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002,
571     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003,
572     VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
573     VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
574     VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
575     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,
576     VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004,
577     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
578     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
579     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
580     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
581     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007,
582     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000,
583     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002,
584     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003,
585     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004,
586     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005,
587     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006,
588     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009,
589     VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010,
590     VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011,
591     VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012,
592     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013,
593     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014,
594     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017,
595     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020,
596     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000,
597     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001,
598     VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015,
599     VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016,
600     VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018,
601     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013,
602     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
603     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000,
604     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001,
605     VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000,
606     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002,
607     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003,
608     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004,
609     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005,
610     VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,
611     VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,
612 #ifdef VK_ENABLE_BETA_EXTENSIONS
613     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000,
614 #endif
615 #ifdef VK_ENABLE_BETA_EXTENSIONS
616     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001,
617 #endif
618     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
619     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,
620     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,
621     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,
622     VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000,
623     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001,
624     VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003,
625     VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004,
626     VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005,
627     VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006,
628     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007,
629     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008,
630     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009,
631     VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011,
632     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012,
633     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,
634     VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,
635     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,
636     VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,
637     VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
638     VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
639     VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
640     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
641     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
642     VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
643     VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
644     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
645 #ifdef VK_ENABLE_BETA_EXTENSIONS
646     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT = 1000187000,
647 #endif
648 #ifdef VK_ENABLE_BETA_EXTENSIONS
649     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT = 1000187001,
650 #endif
651 #ifdef VK_ENABLE_BETA_EXTENSIONS
652     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000187002,
653 #endif
654 #ifdef VK_ENABLE_BETA_EXTENSIONS
655     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000187003,
656 #endif
657 #ifdef VK_ENABLE_BETA_EXTENSIONS
658     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT = 1000187004,
659 #endif
660 #ifdef VK_ENABLE_BETA_EXTENSIONS
661     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT = 1000187005,
662 #endif
663 #ifdef VK_ENABLE_BETA_EXTENSIONS
664     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT = 1000187006,
665 #endif
666     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
667     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
668     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
669     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
670     VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,
671     VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000,
672     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
673     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
674     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,
675     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000,
676     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000,
677     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000,
678     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
679     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,
680     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
681     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000,
682     VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000,
683     VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001,
684     VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002,
685     VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003,
686     VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004,
687     VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005,
688     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000,
689     VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000,
690     VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001,
691     VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000,
692     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000,
693     VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
694     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000,
695     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,
696     VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,
697     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000,
698     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001,
699     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002,
700     VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000,
701     VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001,
702     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002,
703     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003,
704     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004,
705     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
706     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
707     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000,
708     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
709     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
710     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
711     VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,
712     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,
713     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
714     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
715     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = 1000245000,
716     VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
717     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000,
718     VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001,
719     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002,
720     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000,
721     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001,
722     VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002,
723     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000,
724     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000,
725     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000,
726     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001,
727     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002,
728     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000,
729     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
730     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
731     VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
732     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
733     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
734     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
735     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000,
736     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
737     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000,
738     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
739     VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
740     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
741     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
742     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
743     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
744     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
745     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000,
746     VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001,
747     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002,
748     VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003,
749     VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004,
750     VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005,
751     VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006,
752     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007,
753     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000,
754     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001,
755     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
756     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
757     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000,
758     VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001,
759     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000,
760     VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001,
761     VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002,
762     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000,
763     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001,
764     VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000,
765     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001,
766     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002,
767     VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000,
768     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = 1000295000,
769     VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = 1000295001,
770     VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = 1000295002,
771     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = 1000297000,
772 #ifdef VK_ENABLE_BETA_EXTENSIONS
773     VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000,
774 #endif
775 #ifdef VK_ENABLE_BETA_EXTENSIONS
776     VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001,
777 #endif
778     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000,
779     VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001,
780     VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = 1000314000,
781     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = 1000314001,
782     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = 1000314002,
783     VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = 1000314003,
784     VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = 1000314004,
785     VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = 1000314005,
786     VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = 1000314006,
787     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = 1000314007,
788     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008,
789     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009,
790     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000,
791     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = 1000325000,
792     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000,
793     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001,
794     VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002,
795     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000,
796     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001,
797     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002,
798     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000,
799     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000,
800     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001,
801     VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000,
802     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000,
803     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000,
804     VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = 1000337000,
805     VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = 1000337001,
806     VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002,
807     VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003,
808     VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = 1000337004,
809     VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = 1000337005,
810     VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = 1000337006,
811     VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = 1000337007,
812     VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = 1000337008,
813     VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = 1000337009,
814     VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010,
815     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000,
816     VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000,
817     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000,
818     VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002,
819     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000,
820     VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001,
821     VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002,
822     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000,
823     VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000,
824     VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001,
825     VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002,
826     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000,
827     VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001,
828     VK_STRUCTURE_TYPE_SUBPASSS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000,
829     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001,
830     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002,
831     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000,
832     VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000,
833     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000,
834     VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001,
835     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = 1000388000,
836     VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = 1000388001,
837     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000,
838     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001,
839     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
840     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
841     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
842     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
843     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
844     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
845     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
846     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
847     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
848     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
849     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
850     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
851     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
852     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
853     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
854     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
855     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
856     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
857     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
858     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
859     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
860     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
861     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
862     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
863     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
864     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
865     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
866     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
867     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
868     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
869     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
870     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
871     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
872     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
873     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
874     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
875     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
876     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
877     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
878     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
879     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
880     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
881     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
882     VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO,
883     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
884     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,
885     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,
886     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,
887     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,
888     VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO,
889     VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO,
890     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
891     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
892     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
893     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
894     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
895     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
896     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
897     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
898     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR,
899     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
900     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
901     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
902     VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO,
903     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
904     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
905     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
906     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
907     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
908     VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO,
909     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
910     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
911     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
912     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
913     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
914     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
915     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
916     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
917     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
918     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
919     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
920     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
921     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
922     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
923     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
924     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
925     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
926     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
927     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
928     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
929     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
930     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
931     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
932     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
933     VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
934     VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO,
935     VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
936     VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO,
937     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
938     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
939     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
940     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
941     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
942     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
943     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
944     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
945     VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO,
946     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
947     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
948     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
949     VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
950     VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
951     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
952     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
953     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
954 } VkStructureType;
955 
956 typedef enum VkImageLayout {
957     VK_IMAGE_LAYOUT_UNDEFINED = 0,
958     VK_IMAGE_LAYOUT_GENERAL = 1,
959     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
960     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
961     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
962     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
963     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
964     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
965     VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
966     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
967     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
968     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000,
969     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001,
970     VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002,
971     VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003,
972     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
973 #ifdef VK_ENABLE_BETA_EXTENSIONS
974     VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000,
975 #endif
976 #ifdef VK_ENABLE_BETA_EXTENSIONS
977     VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001,
978 #endif
979 #ifdef VK_ENABLE_BETA_EXTENSIONS
980     VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002,
981 #endif
982     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
983     VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
984     VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003,
985 #ifdef VK_ENABLE_BETA_EXTENSIONS
986     VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000,
987 #endif
988 #ifdef VK_ENABLE_BETA_EXTENSIONS
989     VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001,
990 #endif
991 #ifdef VK_ENABLE_BETA_EXTENSIONS
992     VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002,
993 #endif
994     VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = 1000314000,
995     VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = 1000314001,
996     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
997     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
998     VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR,
999     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
1000     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL,
1001     VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
1002     VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,
1003     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
1004 } VkImageLayout;
1005 
1006 typedef enum VkObjectType {
1007     VK_OBJECT_TYPE_UNKNOWN = 0,
1008     VK_OBJECT_TYPE_INSTANCE = 1,
1009     VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
1010     VK_OBJECT_TYPE_DEVICE = 3,
1011     VK_OBJECT_TYPE_QUEUE = 4,
1012     VK_OBJECT_TYPE_SEMAPHORE = 5,
1013     VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
1014     VK_OBJECT_TYPE_FENCE = 7,
1015     VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
1016     VK_OBJECT_TYPE_BUFFER = 9,
1017     VK_OBJECT_TYPE_IMAGE = 10,
1018     VK_OBJECT_TYPE_EVENT = 11,
1019     VK_OBJECT_TYPE_QUERY_POOL = 12,
1020     VK_OBJECT_TYPE_BUFFER_VIEW = 13,
1021     VK_OBJECT_TYPE_IMAGE_VIEW = 14,
1022     VK_OBJECT_TYPE_SHADER_MODULE = 15,
1023     VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
1024     VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
1025     VK_OBJECT_TYPE_RENDER_PASS = 18,
1026     VK_OBJECT_TYPE_PIPELINE = 19,
1027     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
1028     VK_OBJECT_TYPE_SAMPLER = 21,
1029     VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
1030     VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
1031     VK_OBJECT_TYPE_FRAMEBUFFER = 24,
1032     VK_OBJECT_TYPE_COMMAND_POOL = 25,
1033     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,
1034     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
1035     VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
1036     VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
1037     VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
1038     VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
1039     VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
1040 #ifdef VK_ENABLE_BETA_EXTENSIONS
1041     VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000,
1042 #endif
1043 #ifdef VK_ENABLE_BETA_EXTENSIONS
1044     VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001,
1045 #endif
1046     VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000,
1047     VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001,
1048     VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,
1049     VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000,
1050     VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
1051     VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1052     VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000,
1053     VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000,
1054     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000,
1055     VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = 1000295000,
1056     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
1057     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
1058     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
1059 } VkObjectType;
1060 
1061 typedef enum VkVendorId {
1062     VK_VENDOR_ID_VIV = 0x10001,
1063     VK_VENDOR_ID_VSI = 0x10002,
1064     VK_VENDOR_ID_KAZAN = 0x10003,
1065     VK_VENDOR_ID_CODEPLAY = 0x10004,
1066     VK_VENDOR_ID_MESA = 0x10005,
1067     VK_VENDOR_ID_POCL = 0x10006,
1068     VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
1069 } VkVendorId;
1070 
1071 typedef enum VkPipelineCacheHeaderVersion {
1072     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
1073     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
1074 } VkPipelineCacheHeaderVersion;
1075 
1076 typedef enum VkSystemAllocationScope {
1077     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
1078     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
1079     VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
1080     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
1081     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
1082     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
1083 } VkSystemAllocationScope;
1084 
1085 typedef enum VkInternalAllocationType {
1086     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
1087     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
1088 } VkInternalAllocationType;
1089 
1090 typedef enum VkFormat {
1091     VK_FORMAT_UNDEFINED = 0,
1092     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
1093     VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
1094     VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
1095     VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
1096     VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
1097     VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
1098     VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
1099     VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
1100     VK_FORMAT_R8_UNORM = 9,
1101     VK_FORMAT_R8_SNORM = 10,
1102     VK_FORMAT_R8_USCALED = 11,
1103     VK_FORMAT_R8_SSCALED = 12,
1104     VK_FORMAT_R8_UINT = 13,
1105     VK_FORMAT_R8_SINT = 14,
1106     VK_FORMAT_R8_SRGB = 15,
1107     VK_FORMAT_R8G8_UNORM = 16,
1108     VK_FORMAT_R8G8_SNORM = 17,
1109     VK_FORMAT_R8G8_USCALED = 18,
1110     VK_FORMAT_R8G8_SSCALED = 19,
1111     VK_FORMAT_R8G8_UINT = 20,
1112     VK_FORMAT_R8G8_SINT = 21,
1113     VK_FORMAT_R8G8_SRGB = 22,
1114     VK_FORMAT_R8G8B8_UNORM = 23,
1115     VK_FORMAT_R8G8B8_SNORM = 24,
1116     VK_FORMAT_R8G8B8_USCALED = 25,
1117     VK_FORMAT_R8G8B8_SSCALED = 26,
1118     VK_FORMAT_R8G8B8_UINT = 27,
1119     VK_FORMAT_R8G8B8_SINT = 28,
1120     VK_FORMAT_R8G8B8_SRGB = 29,
1121     VK_FORMAT_B8G8R8_UNORM = 30,
1122     VK_FORMAT_B8G8R8_SNORM = 31,
1123     VK_FORMAT_B8G8R8_USCALED = 32,
1124     VK_FORMAT_B8G8R8_SSCALED = 33,
1125     VK_FORMAT_B8G8R8_UINT = 34,
1126     VK_FORMAT_B8G8R8_SINT = 35,
1127     VK_FORMAT_B8G8R8_SRGB = 36,
1128     VK_FORMAT_R8G8B8A8_UNORM = 37,
1129     VK_FORMAT_R8G8B8A8_SNORM = 38,
1130     VK_FORMAT_R8G8B8A8_USCALED = 39,
1131     VK_FORMAT_R8G8B8A8_SSCALED = 40,
1132     VK_FORMAT_R8G8B8A8_UINT = 41,
1133     VK_FORMAT_R8G8B8A8_SINT = 42,
1134     VK_FORMAT_R8G8B8A8_SRGB = 43,
1135     VK_FORMAT_B8G8R8A8_UNORM = 44,
1136     VK_FORMAT_B8G8R8A8_SNORM = 45,
1137     VK_FORMAT_B8G8R8A8_USCALED = 46,
1138     VK_FORMAT_B8G8R8A8_SSCALED = 47,
1139     VK_FORMAT_B8G8R8A8_UINT = 48,
1140     VK_FORMAT_B8G8R8A8_SINT = 49,
1141     VK_FORMAT_B8G8R8A8_SRGB = 50,
1142     VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
1143     VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
1144     VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
1145     VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
1146     VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
1147     VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
1148     VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
1149     VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
1150     VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
1151     VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
1152     VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
1153     VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
1154     VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
1155     VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
1156     VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
1157     VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
1158     VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
1159     VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
1160     VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
1161     VK_FORMAT_R16_UNORM = 70,
1162     VK_FORMAT_R16_SNORM = 71,
1163     VK_FORMAT_R16_USCALED = 72,
1164     VK_FORMAT_R16_SSCALED = 73,
1165     VK_FORMAT_R16_UINT = 74,
1166     VK_FORMAT_R16_SINT = 75,
1167     VK_FORMAT_R16_SFLOAT = 76,
1168     VK_FORMAT_R16G16_UNORM = 77,
1169     VK_FORMAT_R16G16_SNORM = 78,
1170     VK_FORMAT_R16G16_USCALED = 79,
1171     VK_FORMAT_R16G16_SSCALED = 80,
1172     VK_FORMAT_R16G16_UINT = 81,
1173     VK_FORMAT_R16G16_SINT = 82,
1174     VK_FORMAT_R16G16_SFLOAT = 83,
1175     VK_FORMAT_R16G16B16_UNORM = 84,
1176     VK_FORMAT_R16G16B16_SNORM = 85,
1177     VK_FORMAT_R16G16B16_USCALED = 86,
1178     VK_FORMAT_R16G16B16_SSCALED = 87,
1179     VK_FORMAT_R16G16B16_UINT = 88,
1180     VK_FORMAT_R16G16B16_SINT = 89,
1181     VK_FORMAT_R16G16B16_SFLOAT = 90,
1182     VK_FORMAT_R16G16B16A16_UNORM = 91,
1183     VK_FORMAT_R16G16B16A16_SNORM = 92,
1184     VK_FORMAT_R16G16B16A16_USCALED = 93,
1185     VK_FORMAT_R16G16B16A16_SSCALED = 94,
1186     VK_FORMAT_R16G16B16A16_UINT = 95,
1187     VK_FORMAT_R16G16B16A16_SINT = 96,
1188     VK_FORMAT_R16G16B16A16_SFLOAT = 97,
1189     VK_FORMAT_R32_UINT = 98,
1190     VK_FORMAT_R32_SINT = 99,
1191     VK_FORMAT_R32_SFLOAT = 100,
1192     VK_FORMAT_R32G32_UINT = 101,
1193     VK_FORMAT_R32G32_SINT = 102,
1194     VK_FORMAT_R32G32_SFLOAT = 103,
1195     VK_FORMAT_R32G32B32_UINT = 104,
1196     VK_FORMAT_R32G32B32_SINT = 105,
1197     VK_FORMAT_R32G32B32_SFLOAT = 106,
1198     VK_FORMAT_R32G32B32A32_UINT = 107,
1199     VK_FORMAT_R32G32B32A32_SINT = 108,
1200     VK_FORMAT_R32G32B32A32_SFLOAT = 109,
1201     VK_FORMAT_R64_UINT = 110,
1202     VK_FORMAT_R64_SINT = 111,
1203     VK_FORMAT_R64_SFLOAT = 112,
1204     VK_FORMAT_R64G64_UINT = 113,
1205     VK_FORMAT_R64G64_SINT = 114,
1206     VK_FORMAT_R64G64_SFLOAT = 115,
1207     VK_FORMAT_R64G64B64_UINT = 116,
1208     VK_FORMAT_R64G64B64_SINT = 117,
1209     VK_FORMAT_R64G64B64_SFLOAT = 118,
1210     VK_FORMAT_R64G64B64A64_UINT = 119,
1211     VK_FORMAT_R64G64B64A64_SINT = 120,
1212     VK_FORMAT_R64G64B64A64_SFLOAT = 121,
1213     VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
1214     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
1215     VK_FORMAT_D16_UNORM = 124,
1216     VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
1217     VK_FORMAT_D32_SFLOAT = 126,
1218     VK_FORMAT_S8_UINT = 127,
1219     VK_FORMAT_D16_UNORM_S8_UINT = 128,
1220     VK_FORMAT_D24_UNORM_S8_UINT = 129,
1221     VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
1222     VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
1223     VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
1224     VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
1225     VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
1226     VK_FORMAT_BC2_UNORM_BLOCK = 135,
1227     VK_FORMAT_BC2_SRGB_BLOCK = 136,
1228     VK_FORMAT_BC3_UNORM_BLOCK = 137,
1229     VK_FORMAT_BC3_SRGB_BLOCK = 138,
1230     VK_FORMAT_BC4_UNORM_BLOCK = 139,
1231     VK_FORMAT_BC4_SNORM_BLOCK = 140,
1232     VK_FORMAT_BC5_UNORM_BLOCK = 141,
1233     VK_FORMAT_BC5_SNORM_BLOCK = 142,
1234     VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
1235     VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
1236     VK_FORMAT_BC7_UNORM_BLOCK = 145,
1237     VK_FORMAT_BC7_SRGB_BLOCK = 146,
1238     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
1239     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
1240     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
1241     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
1242     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
1243     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
1244     VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
1245     VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
1246     VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
1247     VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
1248     VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
1249     VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
1250     VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
1251     VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
1252     VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
1253     VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
1254     VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
1255     VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
1256     VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
1257     VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
1258     VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
1259     VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
1260     VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
1261     VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
1262     VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
1263     VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
1264     VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
1265     VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
1266     VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
1267     VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
1268     VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
1269     VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
1270     VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
1271     VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
1272     VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
1273     VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
1274     VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
1275     VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
1276     VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000,
1277     VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001,
1278     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,
1279     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,
1280     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,
1281     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,
1282     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,
1283     VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007,
1284     VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,
1285     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
1286     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
1287     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
1288     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
1289     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
1290     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
1291     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
1292     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
1293     VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017,
1294     VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,
1295     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
1296     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
1297     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
1298     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
1299     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
1300     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
1301     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
1302     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
1303     VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027,
1304     VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028,
1305     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,
1306     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,
1307     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,
1308     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,
1309     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
1310     VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
1311     VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
1312     VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
1313     VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
1314     VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
1315     VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
1316     VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
1317     VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
1318     VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000,
1319     VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001,
1320     VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002,
1321     VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003,
1322     VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004,
1323     VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005,
1324     VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006,
1325     VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007,
1326     VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008,
1327     VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009,
1328     VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010,
1329     VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011,
1330     VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012,
1331     VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013,
1332     VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000,
1333     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001,
1334     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002,
1335     VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003,
1336     VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000,
1337     VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001,
1338     VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
1339     VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
1340     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
1341     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
1342     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
1343     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
1344     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
1345     VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16,
1346     VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
1347     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
1348     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
1349     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
1350     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
1351     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
1352     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
1353     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
1354     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
1355     VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16,
1356     VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
1357     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
1358     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
1359     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
1360     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
1361     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
1362     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
1363     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
1364     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
1365     VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM,
1366     VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM,
1367     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
1368     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
1369     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
1370     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
1371     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
1372     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
1373 } VkFormat;
1374 
1375 typedef enum VkImageTiling {
1376     VK_IMAGE_TILING_OPTIMAL = 0,
1377     VK_IMAGE_TILING_LINEAR = 1,
1378     VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000,
1379     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
1380 } VkImageTiling;
1381 
1382 typedef enum VkImageType {
1383     VK_IMAGE_TYPE_1D = 0,
1384     VK_IMAGE_TYPE_2D = 1,
1385     VK_IMAGE_TYPE_3D = 2,
1386     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
1387 } VkImageType;
1388 
1389 typedef enum VkPhysicalDeviceType {
1390     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
1391     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
1392     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
1393     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
1394     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
1395     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
1396 } VkPhysicalDeviceType;
1397 
1398 typedef enum VkQueryType {
1399     VK_QUERY_TYPE_OCCLUSION = 0,
1400     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
1401     VK_QUERY_TYPE_TIMESTAMP = 2,
1402 #ifdef VK_ENABLE_BETA_EXTENSIONS
1403     VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000,
1404 #endif
1405     VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
1406     VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
1407     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000,
1408     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001,
1409     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
1410     VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
1411 #ifdef VK_ENABLE_BETA_EXTENSIONS
1412     VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000,
1413 #endif
1414     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
1415 } VkQueryType;
1416 
1417 typedef enum VkSharingMode {
1418     VK_SHARING_MODE_EXCLUSIVE = 0,
1419     VK_SHARING_MODE_CONCURRENT = 1,
1420     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
1421 } VkSharingMode;
1422 
1423 typedef enum VkComponentSwizzle {
1424     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
1425     VK_COMPONENT_SWIZZLE_ZERO = 1,
1426     VK_COMPONENT_SWIZZLE_ONE = 2,
1427     VK_COMPONENT_SWIZZLE_R = 3,
1428     VK_COMPONENT_SWIZZLE_G = 4,
1429     VK_COMPONENT_SWIZZLE_B = 5,
1430     VK_COMPONENT_SWIZZLE_A = 6,
1431     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
1432 } VkComponentSwizzle;
1433 
1434 typedef enum VkImageViewType {
1435     VK_IMAGE_VIEW_TYPE_1D = 0,
1436     VK_IMAGE_VIEW_TYPE_2D = 1,
1437     VK_IMAGE_VIEW_TYPE_3D = 2,
1438     VK_IMAGE_VIEW_TYPE_CUBE = 3,
1439     VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
1440     VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
1441     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
1442     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
1443 } VkImageViewType;
1444 
1445 typedef enum VkBlendFactor {
1446     VK_BLEND_FACTOR_ZERO = 0,
1447     VK_BLEND_FACTOR_ONE = 1,
1448     VK_BLEND_FACTOR_SRC_COLOR = 2,
1449     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
1450     VK_BLEND_FACTOR_DST_COLOR = 4,
1451     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
1452     VK_BLEND_FACTOR_SRC_ALPHA = 6,
1453     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
1454     VK_BLEND_FACTOR_DST_ALPHA = 8,
1455     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
1456     VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
1457     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
1458     VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
1459     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
1460     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
1461     VK_BLEND_FACTOR_SRC1_COLOR = 15,
1462     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
1463     VK_BLEND_FACTOR_SRC1_ALPHA = 17,
1464     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
1465     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
1466 } VkBlendFactor;
1467 
1468 typedef enum VkBlendOp {
1469     VK_BLEND_OP_ADD = 0,
1470     VK_BLEND_OP_SUBTRACT = 1,
1471     VK_BLEND_OP_REVERSE_SUBTRACT = 2,
1472     VK_BLEND_OP_MIN = 3,
1473     VK_BLEND_OP_MAX = 4,
1474     VK_BLEND_OP_ZERO_EXT = 1000148000,
1475     VK_BLEND_OP_SRC_EXT = 1000148001,
1476     VK_BLEND_OP_DST_EXT = 1000148002,
1477     VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
1478     VK_BLEND_OP_DST_OVER_EXT = 1000148004,
1479     VK_BLEND_OP_SRC_IN_EXT = 1000148005,
1480     VK_BLEND_OP_DST_IN_EXT = 1000148006,
1481     VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
1482     VK_BLEND_OP_DST_OUT_EXT = 1000148008,
1483     VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
1484     VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
1485     VK_BLEND_OP_XOR_EXT = 1000148011,
1486     VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
1487     VK_BLEND_OP_SCREEN_EXT = 1000148013,
1488     VK_BLEND_OP_OVERLAY_EXT = 1000148014,
1489     VK_BLEND_OP_DARKEN_EXT = 1000148015,
1490     VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
1491     VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
1492     VK_BLEND_OP_COLORBURN_EXT = 1000148018,
1493     VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
1494     VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
1495     VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
1496     VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
1497     VK_BLEND_OP_INVERT_EXT = 1000148023,
1498     VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
1499     VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
1500     VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
1501     VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
1502     VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
1503     VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
1504     VK_BLEND_OP_HARDMIX_EXT = 1000148030,
1505     VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
1506     VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
1507     VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
1508     VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
1509     VK_BLEND_OP_PLUS_EXT = 1000148035,
1510     VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
1511     VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
1512     VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
1513     VK_BLEND_OP_MINUS_EXT = 1000148039,
1514     VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
1515     VK_BLEND_OP_CONTRAST_EXT = 1000148041,
1516     VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
1517     VK_BLEND_OP_RED_EXT = 1000148043,
1518     VK_BLEND_OP_GREEN_EXT = 1000148044,
1519     VK_BLEND_OP_BLUE_EXT = 1000148045,
1520     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
1521 } VkBlendOp;
1522 
1523 typedef enum VkCompareOp {
1524     VK_COMPARE_OP_NEVER = 0,
1525     VK_COMPARE_OP_LESS = 1,
1526     VK_COMPARE_OP_EQUAL = 2,
1527     VK_COMPARE_OP_LESS_OR_EQUAL = 3,
1528     VK_COMPARE_OP_GREATER = 4,
1529     VK_COMPARE_OP_NOT_EQUAL = 5,
1530     VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
1531     VK_COMPARE_OP_ALWAYS = 7,
1532     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
1533 } VkCompareOp;
1534 
1535 typedef enum VkDynamicState {
1536     VK_DYNAMIC_STATE_VIEWPORT = 0,
1537     VK_DYNAMIC_STATE_SCISSOR = 1,
1538     VK_DYNAMIC_STATE_LINE_WIDTH = 2,
1539     VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
1540     VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
1541     VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
1542     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
1543     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
1544     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
1545     VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
1546     VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
1547     VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
1548     VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000,
1549     VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
1550     VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
1551     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
1552     VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
1553     VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
1554     VK_DYNAMIC_STATE_CULL_MODE_EXT = 1000267000,
1555     VK_DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001,
1556     VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002,
1557     VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003,
1558     VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004,
1559     VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005,
1560     VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006,
1561     VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007,
1562     VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008,
1563     VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009,
1564     VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010,
1565     VK_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011,
1566     VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000,
1567     VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000,
1568     VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = 1000377001,
1569     VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = 1000377002,
1570     VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,
1571     VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = 1000377004,
1572     VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,
1573     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
1574 } VkDynamicState;
1575 
1576 typedef enum VkFrontFace {
1577     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
1578     VK_FRONT_FACE_CLOCKWISE = 1,
1579     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
1580 } VkFrontFace;
1581 
1582 typedef enum VkVertexInputRate {
1583     VK_VERTEX_INPUT_RATE_VERTEX = 0,
1584     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
1585     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
1586 } VkVertexInputRate;
1587 
1588 typedef enum VkPrimitiveTopology {
1589     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
1590     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
1591     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
1592     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
1593     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
1594     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
1595     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
1596     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
1597     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
1598     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
1599     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
1600     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
1601 } VkPrimitiveTopology;
1602 
1603 typedef enum VkPolygonMode {
1604     VK_POLYGON_MODE_FILL = 0,
1605     VK_POLYGON_MODE_LINE = 1,
1606     VK_POLYGON_MODE_POINT = 2,
1607     VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
1608     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
1609 } VkPolygonMode;
1610 
1611 typedef enum VkStencilOp {
1612     VK_STENCIL_OP_KEEP = 0,
1613     VK_STENCIL_OP_ZERO = 1,
1614     VK_STENCIL_OP_REPLACE = 2,
1615     VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
1616     VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
1617     VK_STENCIL_OP_INVERT = 5,
1618     VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
1619     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
1620     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
1621 } VkStencilOp;
1622 
1623 typedef enum VkLogicOp {
1624     VK_LOGIC_OP_CLEAR = 0,
1625     VK_LOGIC_OP_AND = 1,
1626     VK_LOGIC_OP_AND_REVERSE = 2,
1627     VK_LOGIC_OP_COPY = 3,
1628     VK_LOGIC_OP_AND_INVERTED = 4,
1629     VK_LOGIC_OP_NO_OP = 5,
1630     VK_LOGIC_OP_XOR = 6,
1631     VK_LOGIC_OP_OR = 7,
1632     VK_LOGIC_OP_NOR = 8,
1633     VK_LOGIC_OP_EQUIVALENT = 9,
1634     VK_LOGIC_OP_INVERT = 10,
1635     VK_LOGIC_OP_OR_REVERSE = 11,
1636     VK_LOGIC_OP_COPY_INVERTED = 12,
1637     VK_LOGIC_OP_OR_INVERTED = 13,
1638     VK_LOGIC_OP_NAND = 14,
1639     VK_LOGIC_OP_SET = 15,
1640     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
1641 } VkLogicOp;
1642 
1643 typedef enum VkBorderColor {
1644     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
1645     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
1646     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
1647     VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
1648     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
1649     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
1650     VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003,
1651     VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004,
1652     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
1653 } VkBorderColor;
1654 
1655 typedef enum VkFilter {
1656     VK_FILTER_NEAREST = 0,
1657     VK_FILTER_LINEAR = 1,
1658     VK_FILTER_CUBIC_IMG = 1000015000,
1659     VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG,
1660     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
1661 } VkFilter;
1662 
1663 typedef enum VkSamplerAddressMode {
1664     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
1665     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
1666     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
1667     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
1668     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
1669     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
1670     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
1671 } VkSamplerAddressMode;
1672 
1673 typedef enum VkSamplerMipmapMode {
1674     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
1675     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
1676     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
1677 } VkSamplerMipmapMode;
1678 
1679 typedef enum VkDescriptorType {
1680     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
1681     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
1682     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
1683     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
1684     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
1685     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
1686     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
1687     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
1688     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
1689     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
1690     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
1691     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000,
1692     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000,
1693     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1694     VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = 1000351000,
1695     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
1696 } VkDescriptorType;
1697 
1698 typedef enum VkAttachmentLoadOp {
1699     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
1700     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
1701     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
1702     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
1703 } VkAttachmentLoadOp;
1704 
1705 typedef enum VkAttachmentStoreOp {
1706     VK_ATTACHMENT_STORE_OP_STORE = 0,
1707     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
1708     VK_ATTACHMENT_STORE_OP_NONE_QCOM = 1000301000,
1709     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
1710 } VkAttachmentStoreOp;
1711 
1712 typedef enum VkPipelineBindPoint {
1713     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
1714     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
1715     VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000,
1716     VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003,
1717     VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
1718     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
1719 } VkPipelineBindPoint;
1720 
1721 typedef enum VkCommandBufferLevel {
1722     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
1723     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
1724     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
1725 } VkCommandBufferLevel;
1726 
1727 typedef enum VkIndexType {
1728     VK_INDEX_TYPE_UINT16 = 0,
1729     VK_INDEX_TYPE_UINT32 = 1,
1730     VK_INDEX_TYPE_NONE_KHR = 1000165000,
1731     VK_INDEX_TYPE_UINT8_EXT = 1000265000,
1732     VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR,
1733     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
1734 } VkIndexType;
1735 
1736 typedef enum VkSubpassContents {
1737     VK_SUBPASS_CONTENTS_INLINE = 0,
1738     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
1739     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
1740 } VkSubpassContents;
1741 
1742 typedef enum VkAccessFlagBits {
1743     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
1744     VK_ACCESS_INDEX_READ_BIT = 0x00000002,
1745     VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
1746     VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
1747     VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
1748     VK_ACCESS_SHADER_READ_BIT = 0x00000020,
1749     VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
1750     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
1751     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
1752     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
1753     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
1754     VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
1755     VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
1756     VK_ACCESS_HOST_READ_BIT = 0x00002000,
1757     VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
1758     VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
1759     VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
1760     VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,
1761     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,
1762     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,
1763     VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
1764     VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
1765     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000,
1766     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000,
1767     VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000,
1768     VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000,
1769     VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000,
1770     VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000,
1771     VK_ACCESS_NONE_KHR = 0,
1772     VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR,
1773     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR,
1774     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
1775     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1776 } VkAccessFlagBits;
1777 typedef VkFlags VkAccessFlags;
1778 
1779 typedef enum VkImageAspectFlagBits {
1780     VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
1781     VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
1782     VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
1783     VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
1784     VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010,
1785     VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020,
1786     VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040,
1787     VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080,
1788     VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,
1789     VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,
1790     VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,
1791     VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
1792     VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
1793     VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
1794     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1795 } VkImageAspectFlagBits;
1796 typedef VkFlags VkImageAspectFlags;
1797 
1798 typedef enum VkFormatFeatureFlagBits {
1799     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
1800     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
1801     VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
1802     VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
1803     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
1804     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
1805     VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
1806     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
1807     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
1808     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
1809     VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
1810     VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
1811     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
1812     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000,
1813     VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000,
1814     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000,
1815     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000,
1816     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000,
1817     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000,
1818     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000,
1819     VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000,
1820     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000,
1821     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000,
1822     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
1823 #ifdef VK_ENABLE_BETA_EXTENSIONS
1824     VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000,
1825 #endif
1826 #ifdef VK_ENABLE_BETA_EXTENSIONS
1827     VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000,
1828 #endif
1829     VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000,
1830     VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000,
1831     VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000,
1832 #ifdef VK_ENABLE_BETA_EXTENSIONS
1833     VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000,
1834 #endif
1835 #ifdef VK_ENABLE_BETA_EXTENSIONS
1836     VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000,
1837 #endif
1838     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
1839     VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
1840     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT,
1841     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
1842     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
1843     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
1844     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
1845     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
1846     VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
1847     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
1848     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
1849     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1850 } VkFormatFeatureFlagBits;
1851 typedef VkFlags VkFormatFeatureFlags;
1852 
1853 typedef enum VkImageCreateFlagBits {
1854     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1855     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1856     VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1857     VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
1858     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
1859     VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400,
1860     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040,
1861     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020,
1862     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080,
1863     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,
1864     VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
1865     VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
1866     VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
1867     VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
1868     VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
1869     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
1870     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
1871     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
1872     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
1873     VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
1874     VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
1875     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1876 } VkImageCreateFlagBits;
1877 typedef VkFlags VkImageCreateFlags;
1878 
1879 typedef enum VkSampleCountFlagBits {
1880     VK_SAMPLE_COUNT_1_BIT = 0x00000001,
1881     VK_SAMPLE_COUNT_2_BIT = 0x00000002,
1882     VK_SAMPLE_COUNT_4_BIT = 0x00000004,
1883     VK_SAMPLE_COUNT_8_BIT = 0x00000008,
1884     VK_SAMPLE_COUNT_16_BIT = 0x00000010,
1885     VK_SAMPLE_COUNT_32_BIT = 0x00000020,
1886     VK_SAMPLE_COUNT_64_BIT = 0x00000040,
1887     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1888 } VkSampleCountFlagBits;
1889 typedef VkFlags VkSampleCountFlags;
1890 
1891 typedef enum VkImageUsageFlagBits {
1892     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1893     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
1894     VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
1895     VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
1896     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
1897     VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
1898     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
1899     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
1900 #ifdef VK_ENABLE_BETA_EXTENSIONS
1901     VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400,
1902 #endif
1903 #ifdef VK_ENABLE_BETA_EXTENSIONS
1904     VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800,
1905 #endif
1906 #ifdef VK_ENABLE_BETA_EXTENSIONS
1907     VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000,
1908 #endif
1909     VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200,
1910     VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100,
1911 #ifdef VK_ENABLE_BETA_EXTENSIONS
1912     VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000,
1913 #endif
1914 #ifdef VK_ENABLE_BETA_EXTENSIONS
1915     VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000,
1916 #endif
1917 #ifdef VK_ENABLE_BETA_EXTENSIONS
1918     VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000,
1919 #endif
1920     VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
1921     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1922 } VkImageUsageFlagBits;
1923 typedef VkFlags VkImageUsageFlags;
1924 typedef VkFlags VkInstanceCreateFlags;
1925 
1926 typedef enum VkMemoryHeapFlagBits {
1927     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
1928     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
1929     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
1930     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1931 } VkMemoryHeapFlagBits;
1932 typedef VkFlags VkMemoryHeapFlags;
1933 
1934 typedef enum VkMemoryPropertyFlagBits {
1935     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
1936     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
1937     VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
1938     VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
1939     VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
1940     VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
1941     VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040,
1942     VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080,
1943     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1944 } VkMemoryPropertyFlagBits;
1945 typedef VkFlags VkMemoryPropertyFlags;
1946 
1947 typedef enum VkQueueFlagBits {
1948     VK_QUEUE_GRAPHICS_BIT = 0x00000001,
1949     VK_QUEUE_COMPUTE_BIT = 0x00000002,
1950     VK_QUEUE_TRANSFER_BIT = 0x00000004,
1951     VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
1952     VK_QUEUE_PROTECTED_BIT = 0x00000010,
1953 #ifdef VK_ENABLE_BETA_EXTENSIONS
1954     VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020,
1955 #endif
1956 #ifdef VK_ENABLE_BETA_EXTENSIONS
1957     VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040,
1958 #endif
1959     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1960 } VkQueueFlagBits;
1961 typedef VkFlags VkQueueFlags;
1962 typedef VkFlags VkDeviceCreateFlags;
1963 
1964 typedef enum VkDeviceQueueCreateFlagBits {
1965     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,
1966     VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1967 } VkDeviceQueueCreateFlagBits;
1968 typedef VkFlags VkDeviceQueueCreateFlags;
1969 
1970 typedef enum VkPipelineStageFlagBits {
1971     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
1972     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
1973     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
1974     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
1975     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
1976     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
1977     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
1978     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
1979     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
1980     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
1981     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
1982     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
1983     VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
1984     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
1985     VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
1986     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
1987     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
1988     VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,
1989     VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
1990     VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000,
1991     VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000,
1992     VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000,
1993     VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,
1994     VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,
1995     VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000,
1996     VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000,
1997     VK_PIPELINE_STAGE_NONE_KHR = 0,
1998     VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
1999     VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
2000     VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
2001     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2002 } VkPipelineStageFlagBits;
2003 typedef VkFlags VkPipelineStageFlags;
2004 typedef VkFlags VkMemoryMapFlags;
2005 
2006 typedef enum VkSparseMemoryBindFlagBits {
2007     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
2008     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2009 } VkSparseMemoryBindFlagBits;
2010 typedef VkFlags VkSparseMemoryBindFlags;
2011 
2012 typedef enum VkSparseImageFormatFlagBits {
2013     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
2014     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
2015     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
2016     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2017 } VkSparseImageFormatFlagBits;
2018 typedef VkFlags VkSparseImageFormatFlags;
2019 
2020 typedef enum VkFenceCreateFlagBits {
2021     VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
2022     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2023 } VkFenceCreateFlagBits;
2024 typedef VkFlags VkFenceCreateFlags;
2025 typedef VkFlags VkSemaphoreCreateFlags;
2026 
2027 typedef enum VkEventCreateFlagBits {
2028     VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = 0x00000001,
2029     VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2030 } VkEventCreateFlagBits;
2031 typedef VkFlags VkEventCreateFlags;
2032 
2033 typedef enum VkQueryPipelineStatisticFlagBits {
2034     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
2035     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
2036     VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
2037     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
2038     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
2039     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
2040     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
2041     VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
2042     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
2043     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
2044     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
2045     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2046 } VkQueryPipelineStatisticFlagBits;
2047 typedef VkFlags VkQueryPipelineStatisticFlags;
2048 typedef VkFlags VkQueryPoolCreateFlags;
2049 
2050 typedef enum VkQueryResultFlagBits {
2051     VK_QUERY_RESULT_64_BIT = 0x00000001,
2052     VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
2053     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
2054     VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
2055 #ifdef VK_ENABLE_BETA_EXTENSIONS
2056     VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010,
2057 #endif
2058     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2059 } VkQueryResultFlagBits;
2060 typedef VkFlags VkQueryResultFlags;
2061 
2062 typedef enum VkBufferCreateFlagBits {
2063     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
2064     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
2065     VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
2066     VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
2067     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010,
2068     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
2069     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
2070     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2071 } VkBufferCreateFlagBits;
2072 typedef VkFlags VkBufferCreateFlags;
2073 
2074 typedef enum VkBufferUsageFlagBits {
2075     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
2076     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
2077     VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
2078     VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
2079     VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
2080     VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
2081     VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
2082     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
2083     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
2084     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000,
2085 #ifdef VK_ENABLE_BETA_EXTENSIONS
2086     VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000,
2087 #endif
2088 #ifdef VK_ENABLE_BETA_EXTENSIONS
2089     VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000,
2090 #endif
2091     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800,
2092     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
2093     VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
2094     VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000,
2095     VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000,
2096     VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400,
2097 #ifdef VK_ENABLE_BETA_EXTENSIONS
2098     VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000,
2099 #endif
2100 #ifdef VK_ENABLE_BETA_EXTENSIONS
2101     VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000,
2102 #endif
2103     VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
2104     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
2105     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
2106     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2107 } VkBufferUsageFlagBits;
2108 typedef VkFlags VkBufferUsageFlags;
2109 typedef VkFlags VkBufferViewCreateFlags;
2110 
2111 typedef enum VkImageViewCreateFlagBits {
2112     VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001,
2113     VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002,
2114     VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2115 } VkImageViewCreateFlagBits;
2116 typedef VkFlags VkImageViewCreateFlags;
2117 
2118 typedef enum VkShaderModuleCreateFlagBits {
2119     VK_SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2120 } VkShaderModuleCreateFlagBits;
2121 typedef VkFlags VkShaderModuleCreateFlags;
2122 
2123 typedef enum VkPipelineCacheCreateFlagBits {
2124     VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = 0x00000001,
2125     VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2126 } VkPipelineCacheCreateFlagBits;
2127 typedef VkFlags VkPipelineCacheCreateFlags;
2128 
2129 typedef enum VkColorComponentFlagBits {
2130     VK_COLOR_COMPONENT_R_BIT = 0x00000001,
2131     VK_COLOR_COMPONENT_G_BIT = 0x00000002,
2132     VK_COLOR_COMPONENT_B_BIT = 0x00000004,
2133     VK_COLOR_COMPONENT_A_BIT = 0x00000008,
2134     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2135 } VkColorComponentFlagBits;
2136 typedef VkFlags VkColorComponentFlags;
2137 
2138 typedef enum VkPipelineCreateFlagBits {
2139     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
2140     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
2141     VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
2142     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
2143     VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,
2144     VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000,
2145     VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000,
2146     VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000,
2147     VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000,
2148     VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000,
2149     VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000,
2150     VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000,
2151     VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
2152     VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
2153     VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
2154     VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000,
2155     VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800,
2156     VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = 0x00000100,
2157     VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = 0x00000200,
2158     VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000,
2159     VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
2160     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
2161     VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
2162     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2163 } VkPipelineCreateFlagBits;
2164 typedef VkFlags VkPipelineCreateFlags;
2165 
2166 typedef enum VkPipelineShaderStageCreateFlagBits {
2167     VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001,
2168     VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002,
2169     VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2170 } VkPipelineShaderStageCreateFlagBits;
2171 typedef VkFlags VkPipelineShaderStageCreateFlags;
2172 
2173 typedef enum VkShaderStageFlagBits {
2174     VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
2175     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
2176     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
2177     VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
2178     VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
2179     VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
2180     VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
2181     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
2182     VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100,
2183     VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200,
2184     VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400,
2185     VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800,
2186     VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000,
2187     VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000,
2188     VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040,
2189     VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,
2190     VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000,
2191     VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
2192     VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
2193     VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
2194     VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR,
2195     VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
2196     VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
2197     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2198 } VkShaderStageFlagBits;
2199 
2200 typedef enum VkCullModeFlagBits {
2201     VK_CULL_MODE_NONE = 0,
2202     VK_CULL_MODE_FRONT_BIT = 0x00000001,
2203     VK_CULL_MODE_BACK_BIT = 0x00000002,
2204     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
2205     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2206 } VkCullModeFlagBits;
2207 typedef VkFlags VkCullModeFlags;
2208 typedef VkFlags VkPipelineVertexInputStateCreateFlags;
2209 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
2210 typedef VkFlags VkPipelineTessellationStateCreateFlags;
2211 typedef VkFlags VkPipelineViewportStateCreateFlags;
2212 typedef VkFlags VkPipelineRasterizationStateCreateFlags;
2213 typedef VkFlags VkPipelineMultisampleStateCreateFlags;
2214 typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
2215 typedef VkFlags VkPipelineColorBlendStateCreateFlags;
2216 typedef VkFlags VkPipelineDynamicStateCreateFlags;
2217 typedef VkFlags VkPipelineLayoutCreateFlags;
2218 typedef VkFlags VkShaderStageFlags;
2219 
2220 typedef enum VkSamplerCreateFlagBits {
2221     VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001,
2222     VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002,
2223     VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2224 } VkSamplerCreateFlagBits;
2225 typedef VkFlags VkSamplerCreateFlags;
2226 
2227 typedef enum VkDescriptorPoolCreateFlagBits {
2228     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
2229     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002,
2230     VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = 0x00000004,
2231     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
2232     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2233 } VkDescriptorPoolCreateFlagBits;
2234 typedef VkFlags VkDescriptorPoolCreateFlags;
2235 typedef VkFlags VkDescriptorPoolResetFlags;
2236 
2237 typedef enum VkDescriptorSetLayoutCreateFlagBits {
2238     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002,
2239     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
2240     VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = 0x00000004,
2241     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
2242     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2243 } VkDescriptorSetLayoutCreateFlagBits;
2244 typedef VkFlags VkDescriptorSetLayoutCreateFlags;
2245 
2246 typedef enum VkAttachmentDescriptionFlagBits {
2247     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
2248     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2249 } VkAttachmentDescriptionFlagBits;
2250 typedef VkFlags VkAttachmentDescriptionFlags;
2251 
2252 typedef enum VkDependencyFlagBits {
2253     VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
2254     VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,
2255     VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,
2256     VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
2257     VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
2258     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2259 } VkDependencyFlagBits;
2260 typedef VkFlags VkDependencyFlags;
2261 
2262 typedef enum VkFramebufferCreateFlagBits {
2263     VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001,
2264     VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,
2265     VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2266 } VkFramebufferCreateFlagBits;
2267 typedef VkFlags VkFramebufferCreateFlags;
2268 
2269 typedef enum VkRenderPassCreateFlagBits {
2270     VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002,
2271     VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2272 } VkRenderPassCreateFlagBits;
2273 typedef VkFlags VkRenderPassCreateFlags;
2274 
2275 typedef enum VkSubpassDescriptionFlagBits {
2276     VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
2277     VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
2278     VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004,
2279     VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008,
2280     VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2281 } VkSubpassDescriptionFlagBits;
2282 typedef VkFlags VkSubpassDescriptionFlags;
2283 
2284 typedef enum VkCommandPoolCreateFlagBits {
2285     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
2286     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
2287     VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004,
2288     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2289 } VkCommandPoolCreateFlagBits;
2290 typedef VkFlags VkCommandPoolCreateFlags;
2291 
2292 typedef enum VkCommandPoolResetFlagBits {
2293     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
2294     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2295 } VkCommandPoolResetFlagBits;
2296 typedef VkFlags VkCommandPoolResetFlags;
2297 
2298 typedef enum VkCommandBufferUsageFlagBits {
2299     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
2300     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
2301     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
2302     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2303 } VkCommandBufferUsageFlagBits;
2304 typedef VkFlags VkCommandBufferUsageFlags;
2305 
2306 typedef enum VkQueryControlFlagBits {
2307     VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
2308     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2309 } VkQueryControlFlagBits;
2310 typedef VkFlags VkQueryControlFlags;
2311 
2312 typedef enum VkCommandBufferResetFlagBits {
2313     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
2314     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2315 } VkCommandBufferResetFlagBits;
2316 typedef VkFlags VkCommandBufferResetFlags;
2317 
2318 typedef enum VkStencilFaceFlagBits {
2319     VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
2320     VK_STENCIL_FACE_BACK_BIT = 0x00000002,
2321     VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,
2322     VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
2323     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
2324 } VkStencilFaceFlagBits;
2325 typedef VkFlags VkStencilFaceFlags;
2326 typedef struct VkExtent2D {
2327     uint32_t    width;
2328     uint32_t    height;
2329 } VkExtent2D;
2330 
2331 typedef struct VkExtent3D {
2332     uint32_t    width;
2333     uint32_t    height;
2334     uint32_t    depth;
2335 } VkExtent3D;
2336 
2337 typedef struct VkOffset2D {
2338     int32_t    x;
2339     int32_t    y;
2340 } VkOffset2D;
2341 
2342 typedef struct VkOffset3D {
2343     int32_t    x;
2344     int32_t    y;
2345     int32_t    z;
2346 } VkOffset3D;
2347 
2348 typedef struct VkRect2D {
2349     VkOffset2D    offset;
2350     VkExtent2D    extent;
2351 } VkRect2D;
2352 
2353 typedef struct VkBaseInStructure {
2354     VkStructureType                    sType;
2355     const struct VkBaseInStructure*    pNext;
2356 } VkBaseInStructure;
2357 
2358 typedef struct VkBaseOutStructure {
2359     VkStructureType               sType;
2360     struct VkBaseOutStructure*    pNext;
2361 } VkBaseOutStructure;
2362 
2363 typedef struct VkBufferMemoryBarrier {
2364     VkStructureType    sType;
2365     const void*        pNext;
2366     VkAccessFlags      srcAccessMask;
2367     VkAccessFlags      dstAccessMask;
2368     uint32_t           srcQueueFamilyIndex;
2369     uint32_t           dstQueueFamilyIndex;
2370     VkBuffer           buffer;
2371     VkDeviceSize       offset;
2372     VkDeviceSize       size;
2373 } VkBufferMemoryBarrier;
2374 
2375 typedef struct VkDispatchIndirectCommand {
2376     uint32_t    x;
2377     uint32_t    y;
2378     uint32_t    z;
2379 } VkDispatchIndirectCommand;
2380 
2381 typedef struct VkDrawIndexedIndirectCommand {
2382     uint32_t    indexCount;
2383     uint32_t    instanceCount;
2384     uint32_t    firstIndex;
2385     int32_t     vertexOffset;
2386     uint32_t    firstInstance;
2387 } VkDrawIndexedIndirectCommand;
2388 
2389 typedef struct VkDrawIndirectCommand {
2390     uint32_t    vertexCount;
2391     uint32_t    instanceCount;
2392     uint32_t    firstVertex;
2393     uint32_t    firstInstance;
2394 } VkDrawIndirectCommand;
2395 
2396 typedef struct VkImageSubresourceRange {
2397     VkImageAspectFlags    aspectMask;
2398     uint32_t              baseMipLevel;
2399     uint32_t              levelCount;
2400     uint32_t              baseArrayLayer;
2401     uint32_t              layerCount;
2402 } VkImageSubresourceRange;
2403 
2404 typedef struct VkImageMemoryBarrier {
2405     VkStructureType            sType;
2406     const void*                pNext;
2407     VkAccessFlags              srcAccessMask;
2408     VkAccessFlags              dstAccessMask;
2409     VkImageLayout              oldLayout;
2410     VkImageLayout              newLayout;
2411     uint32_t                   srcQueueFamilyIndex;
2412     uint32_t                   dstQueueFamilyIndex;
2413     VkImage                    image;
2414     VkImageSubresourceRange    subresourceRange;
2415 } VkImageMemoryBarrier;
2416 
2417 typedef struct VkMemoryBarrier {
2418     VkStructureType    sType;
2419     const void*        pNext;
2420     VkAccessFlags      srcAccessMask;
2421     VkAccessFlags      dstAccessMask;
2422 } VkMemoryBarrier;
2423 
2424 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
2425     void*                                       pUserData,
2426     size_t                                      size,
2427     size_t                                      alignment,
2428     VkSystemAllocationScope                     allocationScope);
2429 
2430 typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
2431     void*                                       pUserData,
2432     void*                                       pMemory);
2433 
2434 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
2435     void*                                       pUserData,
2436     size_t                                      size,
2437     VkInternalAllocationType                    allocationType,
2438     VkSystemAllocationScope                     allocationScope);
2439 
2440 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
2441     void*                                       pUserData,
2442     size_t                                      size,
2443     VkInternalAllocationType                    allocationType,
2444     VkSystemAllocationScope                     allocationScope);
2445 
2446 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
2447     void*                                       pUserData,
2448     void*                                       pOriginal,
2449     size_t                                      size,
2450     size_t                                      alignment,
2451     VkSystemAllocationScope                     allocationScope);
2452 
2453 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
2454 typedef struct VkAllocationCallbacks {
2455     void*                                   pUserData;
2456     PFN_vkAllocationFunction                pfnAllocation;
2457     PFN_vkReallocationFunction              pfnReallocation;
2458     PFN_vkFreeFunction                      pfnFree;
2459     PFN_vkInternalAllocationNotification    pfnInternalAllocation;
2460     PFN_vkInternalFreeNotification          pfnInternalFree;
2461 } VkAllocationCallbacks;
2462 
2463 typedef struct VkApplicationInfo {
2464     VkStructureType    sType;
2465     const void*        pNext;
2466     const char*        pApplicationName;
2467     uint32_t           applicationVersion;
2468     const char*        pEngineName;
2469     uint32_t           engineVersion;
2470     uint32_t           apiVersion;
2471 } VkApplicationInfo;
2472 
2473 typedef struct VkFormatProperties {
2474     VkFormatFeatureFlags    linearTilingFeatures;
2475     VkFormatFeatureFlags    optimalTilingFeatures;
2476     VkFormatFeatureFlags    bufferFeatures;
2477 } VkFormatProperties;
2478 
2479 typedef struct VkImageFormatProperties {
2480     VkExtent3D            maxExtent;
2481     uint32_t              maxMipLevels;
2482     uint32_t              maxArrayLayers;
2483     VkSampleCountFlags    sampleCounts;
2484     VkDeviceSize          maxResourceSize;
2485 } VkImageFormatProperties;
2486 
2487 typedef struct VkInstanceCreateInfo {
2488     VkStructureType             sType;
2489     const void*                 pNext;
2490     VkInstanceCreateFlags       flags;
2491     const VkApplicationInfo*    pApplicationInfo;
2492     uint32_t                    enabledLayerCount;
2493     const char* const*          ppEnabledLayerNames;
2494     uint32_t                    enabledExtensionCount;
2495     const char* const*          ppEnabledExtensionNames;
2496 } VkInstanceCreateInfo;
2497 
2498 typedef struct VkMemoryHeap {
2499     VkDeviceSize         size;
2500     VkMemoryHeapFlags    flags;
2501 } VkMemoryHeap;
2502 
2503 typedef struct VkMemoryType {
2504     VkMemoryPropertyFlags    propertyFlags;
2505     uint32_t                 heapIndex;
2506 } VkMemoryType;
2507 
2508 typedef struct VkPhysicalDeviceFeatures {
2509     VkBool32    robustBufferAccess;
2510     VkBool32    fullDrawIndexUint32;
2511     VkBool32    imageCubeArray;
2512     VkBool32    independentBlend;
2513     VkBool32    geometryShader;
2514     VkBool32    tessellationShader;
2515     VkBool32    sampleRateShading;
2516     VkBool32    dualSrcBlend;
2517     VkBool32    logicOp;
2518     VkBool32    multiDrawIndirect;
2519     VkBool32    drawIndirectFirstInstance;
2520     VkBool32    depthClamp;
2521     VkBool32    depthBiasClamp;
2522     VkBool32    fillModeNonSolid;
2523     VkBool32    depthBounds;
2524     VkBool32    wideLines;
2525     VkBool32    largePoints;
2526     VkBool32    alphaToOne;
2527     VkBool32    multiViewport;
2528     VkBool32    samplerAnisotropy;
2529     VkBool32    textureCompressionETC2;
2530     VkBool32    textureCompressionASTC_LDR;
2531     VkBool32    textureCompressionBC;
2532     VkBool32    occlusionQueryPrecise;
2533     VkBool32    pipelineStatisticsQuery;
2534     VkBool32    vertexPipelineStoresAndAtomics;
2535     VkBool32    fragmentStoresAndAtomics;
2536     VkBool32    shaderTessellationAndGeometryPointSize;
2537     VkBool32    shaderImageGatherExtended;
2538     VkBool32    shaderStorageImageExtendedFormats;
2539     VkBool32    shaderStorageImageMultisample;
2540     VkBool32    shaderStorageImageReadWithoutFormat;
2541     VkBool32    shaderStorageImageWriteWithoutFormat;
2542     VkBool32    shaderUniformBufferArrayDynamicIndexing;
2543     VkBool32    shaderSampledImageArrayDynamicIndexing;
2544     VkBool32    shaderStorageBufferArrayDynamicIndexing;
2545     VkBool32    shaderStorageImageArrayDynamicIndexing;
2546     VkBool32    shaderClipDistance;
2547     VkBool32    shaderCullDistance;
2548     VkBool32    shaderFloat64;
2549     VkBool32    shaderInt64;
2550     VkBool32    shaderInt16;
2551     VkBool32    shaderResourceResidency;
2552     VkBool32    shaderResourceMinLod;
2553     VkBool32    sparseBinding;
2554     VkBool32    sparseResidencyBuffer;
2555     VkBool32    sparseResidencyImage2D;
2556     VkBool32    sparseResidencyImage3D;
2557     VkBool32    sparseResidency2Samples;
2558     VkBool32    sparseResidency4Samples;
2559     VkBool32    sparseResidency8Samples;
2560     VkBool32    sparseResidency16Samples;
2561     VkBool32    sparseResidencyAliased;
2562     VkBool32    variableMultisampleRate;
2563     VkBool32    inheritedQueries;
2564 } VkPhysicalDeviceFeatures;
2565 
2566 typedef struct VkPhysicalDeviceLimits {
2567     uint32_t              maxImageDimension1D;
2568     uint32_t              maxImageDimension2D;
2569     uint32_t              maxImageDimension3D;
2570     uint32_t              maxImageDimensionCube;
2571     uint32_t              maxImageArrayLayers;
2572     uint32_t              maxTexelBufferElements;
2573     uint32_t              maxUniformBufferRange;
2574     uint32_t              maxStorageBufferRange;
2575     uint32_t              maxPushConstantsSize;
2576     uint32_t              maxMemoryAllocationCount;
2577     uint32_t              maxSamplerAllocationCount;
2578     VkDeviceSize          bufferImageGranularity;
2579     VkDeviceSize          sparseAddressSpaceSize;
2580     uint32_t              maxBoundDescriptorSets;
2581     uint32_t              maxPerStageDescriptorSamplers;
2582     uint32_t              maxPerStageDescriptorUniformBuffers;
2583     uint32_t              maxPerStageDescriptorStorageBuffers;
2584     uint32_t              maxPerStageDescriptorSampledImages;
2585     uint32_t              maxPerStageDescriptorStorageImages;
2586     uint32_t              maxPerStageDescriptorInputAttachments;
2587     uint32_t              maxPerStageResources;
2588     uint32_t              maxDescriptorSetSamplers;
2589     uint32_t              maxDescriptorSetUniformBuffers;
2590     uint32_t              maxDescriptorSetUniformBuffersDynamic;
2591     uint32_t              maxDescriptorSetStorageBuffers;
2592     uint32_t              maxDescriptorSetStorageBuffersDynamic;
2593     uint32_t              maxDescriptorSetSampledImages;
2594     uint32_t              maxDescriptorSetStorageImages;
2595     uint32_t              maxDescriptorSetInputAttachments;
2596     uint32_t              maxVertexInputAttributes;
2597     uint32_t              maxVertexInputBindings;
2598     uint32_t              maxVertexInputAttributeOffset;
2599     uint32_t              maxVertexInputBindingStride;
2600     uint32_t              maxVertexOutputComponents;
2601     uint32_t              maxTessellationGenerationLevel;
2602     uint32_t              maxTessellationPatchSize;
2603     uint32_t              maxTessellationControlPerVertexInputComponents;
2604     uint32_t              maxTessellationControlPerVertexOutputComponents;
2605     uint32_t              maxTessellationControlPerPatchOutputComponents;
2606     uint32_t              maxTessellationControlTotalOutputComponents;
2607     uint32_t              maxTessellationEvaluationInputComponents;
2608     uint32_t              maxTessellationEvaluationOutputComponents;
2609     uint32_t              maxGeometryShaderInvocations;
2610     uint32_t              maxGeometryInputComponents;
2611     uint32_t              maxGeometryOutputComponents;
2612     uint32_t              maxGeometryOutputVertices;
2613     uint32_t              maxGeometryTotalOutputComponents;
2614     uint32_t              maxFragmentInputComponents;
2615     uint32_t              maxFragmentOutputAttachments;
2616     uint32_t              maxFragmentDualSrcAttachments;
2617     uint32_t              maxFragmentCombinedOutputResources;
2618     uint32_t              maxComputeSharedMemorySize;
2619     uint32_t              maxComputeWorkGroupCount[3];
2620     uint32_t              maxComputeWorkGroupInvocations;
2621     uint32_t              maxComputeWorkGroupSize[3];
2622     uint32_t              subPixelPrecisionBits;
2623     uint32_t              subTexelPrecisionBits;
2624     uint32_t              mipmapPrecisionBits;
2625     uint32_t              maxDrawIndexedIndexValue;
2626     uint32_t              maxDrawIndirectCount;
2627     float                 maxSamplerLodBias;
2628     float                 maxSamplerAnisotropy;
2629     uint32_t              maxViewports;
2630     uint32_t              maxViewportDimensions[2];
2631     float                 viewportBoundsRange[2];
2632     uint32_t              viewportSubPixelBits;
2633     size_t                minMemoryMapAlignment;
2634     VkDeviceSize          minTexelBufferOffsetAlignment;
2635     VkDeviceSize          minUniformBufferOffsetAlignment;
2636     VkDeviceSize          minStorageBufferOffsetAlignment;
2637     int32_t               minTexelOffset;
2638     uint32_t              maxTexelOffset;
2639     int32_t               minTexelGatherOffset;
2640     uint32_t              maxTexelGatherOffset;
2641     float                 minInterpolationOffset;
2642     float                 maxInterpolationOffset;
2643     uint32_t              subPixelInterpolationOffsetBits;
2644     uint32_t              maxFramebufferWidth;
2645     uint32_t              maxFramebufferHeight;
2646     uint32_t              maxFramebufferLayers;
2647     VkSampleCountFlags    framebufferColorSampleCounts;
2648     VkSampleCountFlags    framebufferDepthSampleCounts;
2649     VkSampleCountFlags    framebufferStencilSampleCounts;
2650     VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
2651     uint32_t              maxColorAttachments;
2652     VkSampleCountFlags    sampledImageColorSampleCounts;
2653     VkSampleCountFlags    sampledImageIntegerSampleCounts;
2654     VkSampleCountFlags    sampledImageDepthSampleCounts;
2655     VkSampleCountFlags    sampledImageStencilSampleCounts;
2656     VkSampleCountFlags    storageImageSampleCounts;
2657     uint32_t              maxSampleMaskWords;
2658     VkBool32              timestampComputeAndGraphics;
2659     float                 timestampPeriod;
2660     uint32_t              maxClipDistances;
2661     uint32_t              maxCullDistances;
2662     uint32_t              maxCombinedClipAndCullDistances;
2663     uint32_t              discreteQueuePriorities;
2664     float                 pointSizeRange[2];
2665     float                 lineWidthRange[2];
2666     float                 pointSizeGranularity;
2667     float                 lineWidthGranularity;
2668     VkBool32              strictLines;
2669     VkBool32              standardSampleLocations;
2670     VkDeviceSize          optimalBufferCopyOffsetAlignment;
2671     VkDeviceSize          optimalBufferCopyRowPitchAlignment;
2672     VkDeviceSize          nonCoherentAtomSize;
2673 } VkPhysicalDeviceLimits;
2674 
2675 typedef struct VkPhysicalDeviceMemoryProperties {
2676     uint32_t        memoryTypeCount;
2677     VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
2678     uint32_t        memoryHeapCount;
2679     VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
2680 } VkPhysicalDeviceMemoryProperties;
2681 
2682 typedef struct VkPhysicalDeviceSparseProperties {
2683     VkBool32    residencyStandard2DBlockShape;
2684     VkBool32    residencyStandard2DMultisampleBlockShape;
2685     VkBool32    residencyStandard3DBlockShape;
2686     VkBool32    residencyAlignedMipSize;
2687     VkBool32    residencyNonResidentStrict;
2688 } VkPhysicalDeviceSparseProperties;
2689 
2690 typedef struct VkPhysicalDeviceProperties {
2691     uint32_t                            apiVersion;
2692     uint32_t                            driverVersion;
2693     uint32_t                            vendorID;
2694     uint32_t                            deviceID;
2695     VkPhysicalDeviceType                deviceType;
2696     char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
2697     uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
2698     VkPhysicalDeviceLimits              limits;
2699     VkPhysicalDeviceSparseProperties    sparseProperties;
2700 } VkPhysicalDeviceProperties;
2701 
2702 typedef struct VkQueueFamilyProperties {
2703     VkQueueFlags    queueFlags;
2704     uint32_t        queueCount;
2705     uint32_t        timestampValidBits;
2706     VkExtent3D      minImageTransferGranularity;
2707 } VkQueueFamilyProperties;
2708 
2709 typedef struct VkDeviceQueueCreateInfo {
2710     VkStructureType             sType;
2711     const void*                 pNext;
2712     VkDeviceQueueCreateFlags    flags;
2713     uint32_t                    queueFamilyIndex;
2714     uint32_t                    queueCount;
2715     const float*                pQueuePriorities;
2716 } VkDeviceQueueCreateInfo;
2717 
2718 typedef struct VkDeviceCreateInfo {
2719     VkStructureType                    sType;
2720     const void*                        pNext;
2721     VkDeviceCreateFlags                flags;
2722     uint32_t                           queueCreateInfoCount;
2723     const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
2724     uint32_t                           enabledLayerCount;
2725     const char* const*                 ppEnabledLayerNames;
2726     uint32_t                           enabledExtensionCount;
2727     const char* const*                 ppEnabledExtensionNames;
2728     const VkPhysicalDeviceFeatures*    pEnabledFeatures;
2729 } VkDeviceCreateInfo;
2730 
2731 typedef struct VkExtensionProperties {
2732     char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
2733     uint32_t    specVersion;
2734 } VkExtensionProperties;
2735 
2736 typedef struct VkLayerProperties {
2737     char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
2738     uint32_t    specVersion;
2739     uint32_t    implementationVersion;
2740     char        description[VK_MAX_DESCRIPTION_SIZE];
2741 } VkLayerProperties;
2742 
2743 typedef struct VkSubmitInfo {
2744     VkStructureType                sType;
2745     const void*                    pNext;
2746     uint32_t                       waitSemaphoreCount;
2747     const VkSemaphore*             pWaitSemaphores;
2748     const VkPipelineStageFlags*    pWaitDstStageMask;
2749     uint32_t                       commandBufferCount;
2750     const VkCommandBuffer*         pCommandBuffers;
2751     uint32_t                       signalSemaphoreCount;
2752     const VkSemaphore*             pSignalSemaphores;
2753 } VkSubmitInfo;
2754 
2755 typedef struct VkMappedMemoryRange {
2756     VkStructureType    sType;
2757     const void*        pNext;
2758     VkDeviceMemory     memory;
2759     VkDeviceSize       offset;
2760     VkDeviceSize       size;
2761 } VkMappedMemoryRange;
2762 
2763 typedef struct VkMemoryAllocateInfo {
2764     VkStructureType    sType;
2765     const void*        pNext;
2766     VkDeviceSize       allocationSize;
2767     uint32_t           memoryTypeIndex;
2768 } VkMemoryAllocateInfo;
2769 
2770 typedef struct VkMemoryRequirements {
2771     VkDeviceSize    size;
2772     VkDeviceSize    alignment;
2773     uint32_t        memoryTypeBits;
2774 } VkMemoryRequirements;
2775 
2776 typedef struct VkSparseMemoryBind {
2777     VkDeviceSize               resourceOffset;
2778     VkDeviceSize               size;
2779     VkDeviceMemory             memory;
2780     VkDeviceSize               memoryOffset;
2781     VkSparseMemoryBindFlags    flags;
2782 } VkSparseMemoryBind;
2783 
2784 typedef struct VkSparseBufferMemoryBindInfo {
2785     VkBuffer                     buffer;
2786     uint32_t                     bindCount;
2787     const VkSparseMemoryBind*    pBinds;
2788 } VkSparseBufferMemoryBindInfo;
2789 
2790 typedef struct VkSparseImageOpaqueMemoryBindInfo {
2791     VkImage                      image;
2792     uint32_t                     bindCount;
2793     const VkSparseMemoryBind*    pBinds;
2794 } VkSparseImageOpaqueMemoryBindInfo;
2795 
2796 typedef struct VkImageSubresource {
2797     VkImageAspectFlags    aspectMask;
2798     uint32_t              mipLevel;
2799     uint32_t              arrayLayer;
2800 } VkImageSubresource;
2801 
2802 typedef struct VkSparseImageMemoryBind {
2803     VkImageSubresource         subresource;
2804     VkOffset3D                 offset;
2805     VkExtent3D                 extent;
2806     VkDeviceMemory             memory;
2807     VkDeviceSize               memoryOffset;
2808     VkSparseMemoryBindFlags    flags;
2809 } VkSparseImageMemoryBind;
2810 
2811 typedef struct VkSparseImageMemoryBindInfo {
2812     VkImage                           image;
2813     uint32_t                          bindCount;
2814     const VkSparseImageMemoryBind*    pBinds;
2815 } VkSparseImageMemoryBindInfo;
2816 
2817 typedef struct VkBindSparseInfo {
2818     VkStructureType                             sType;
2819     const void*                                 pNext;
2820     uint32_t                                    waitSemaphoreCount;
2821     const VkSemaphore*                          pWaitSemaphores;
2822     uint32_t                                    bufferBindCount;
2823     const VkSparseBufferMemoryBindInfo*         pBufferBinds;
2824     uint32_t                                    imageOpaqueBindCount;
2825     const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
2826     uint32_t                                    imageBindCount;
2827     const VkSparseImageMemoryBindInfo*          pImageBinds;
2828     uint32_t                                    signalSemaphoreCount;
2829     const VkSemaphore*                          pSignalSemaphores;
2830 } VkBindSparseInfo;
2831 
2832 typedef struct VkSparseImageFormatProperties {
2833     VkImageAspectFlags          aspectMask;
2834     VkExtent3D                  imageGranularity;
2835     VkSparseImageFormatFlags    flags;
2836 } VkSparseImageFormatProperties;
2837 
2838 typedef struct VkSparseImageMemoryRequirements {
2839     VkSparseImageFormatProperties    formatProperties;
2840     uint32_t                         imageMipTailFirstLod;
2841     VkDeviceSize                     imageMipTailSize;
2842     VkDeviceSize                     imageMipTailOffset;
2843     VkDeviceSize                     imageMipTailStride;
2844 } VkSparseImageMemoryRequirements;
2845 
2846 typedef struct VkFenceCreateInfo {
2847     VkStructureType       sType;
2848     const void*           pNext;
2849     VkFenceCreateFlags    flags;
2850 } VkFenceCreateInfo;
2851 
2852 typedef struct VkSemaphoreCreateInfo {
2853     VkStructureType           sType;
2854     const void*               pNext;
2855     VkSemaphoreCreateFlags    flags;
2856 } VkSemaphoreCreateInfo;
2857 
2858 typedef struct VkEventCreateInfo {
2859     VkStructureType       sType;
2860     const void*           pNext;
2861     VkEventCreateFlags    flags;
2862 } VkEventCreateInfo;
2863 
2864 typedef struct VkQueryPoolCreateInfo {
2865     VkStructureType                  sType;
2866     const void*                      pNext;
2867     VkQueryPoolCreateFlags           flags;
2868     VkQueryType                      queryType;
2869     uint32_t                         queryCount;
2870     VkQueryPipelineStatisticFlags    pipelineStatistics;
2871 } VkQueryPoolCreateInfo;
2872 
2873 typedef struct VkBufferCreateInfo {
2874     VkStructureType        sType;
2875     const void*            pNext;
2876     VkBufferCreateFlags    flags;
2877     VkDeviceSize           size;
2878     VkBufferUsageFlags     usage;
2879     VkSharingMode          sharingMode;
2880     uint32_t               queueFamilyIndexCount;
2881     const uint32_t*        pQueueFamilyIndices;
2882 } VkBufferCreateInfo;
2883 
2884 typedef struct VkBufferViewCreateInfo {
2885     VkStructureType            sType;
2886     const void*                pNext;
2887     VkBufferViewCreateFlags    flags;
2888     VkBuffer                   buffer;
2889     VkFormat                   format;
2890     VkDeviceSize               offset;
2891     VkDeviceSize               range;
2892 } VkBufferViewCreateInfo;
2893 
2894 typedef struct VkImageCreateInfo {
2895     VkStructureType          sType;
2896     const void*              pNext;
2897     VkImageCreateFlags       flags;
2898     VkImageType              imageType;
2899     VkFormat                 format;
2900     VkExtent3D               extent;
2901     uint32_t                 mipLevels;
2902     uint32_t                 arrayLayers;
2903     VkSampleCountFlagBits    samples;
2904     VkImageTiling            tiling;
2905     VkImageUsageFlags        usage;
2906     VkSharingMode            sharingMode;
2907     uint32_t                 queueFamilyIndexCount;
2908     const uint32_t*          pQueueFamilyIndices;
2909     VkImageLayout            initialLayout;
2910 } VkImageCreateInfo;
2911 
2912 typedef struct VkSubresourceLayout {
2913     VkDeviceSize    offset;
2914     VkDeviceSize    size;
2915     VkDeviceSize    rowPitch;
2916     VkDeviceSize    arrayPitch;
2917     VkDeviceSize    depthPitch;
2918 } VkSubresourceLayout;
2919 
2920 typedef struct VkComponentMapping {
2921     VkComponentSwizzle    r;
2922     VkComponentSwizzle    g;
2923     VkComponentSwizzle    b;
2924     VkComponentSwizzle    a;
2925 } VkComponentMapping;
2926 
2927 typedef struct VkImageViewCreateInfo {
2928     VkStructureType            sType;
2929     const void*                pNext;
2930     VkImageViewCreateFlags     flags;
2931     VkImage                    image;
2932     VkImageViewType            viewType;
2933     VkFormat                   format;
2934     VkComponentMapping         components;
2935     VkImageSubresourceRange    subresourceRange;
2936 } VkImageViewCreateInfo;
2937 
2938 typedef struct VkShaderModuleCreateInfo {
2939     VkStructureType              sType;
2940     const void*                  pNext;
2941     VkShaderModuleCreateFlags    flags;
2942     size_t                       codeSize;
2943     const uint32_t*              pCode;
2944 } VkShaderModuleCreateInfo;
2945 
2946 typedef struct VkPipelineCacheCreateInfo {
2947     VkStructureType               sType;
2948     const void*                   pNext;
2949     VkPipelineCacheCreateFlags    flags;
2950     size_t                        initialDataSize;
2951     const void*                   pInitialData;
2952 } VkPipelineCacheCreateInfo;
2953 
2954 typedef struct VkSpecializationMapEntry {
2955     uint32_t    constantID;
2956     uint32_t    offset;
2957     size_t      size;
2958 } VkSpecializationMapEntry;
2959 
2960 typedef struct VkSpecializationInfo {
2961     uint32_t                           mapEntryCount;
2962     const VkSpecializationMapEntry*    pMapEntries;
2963     size_t                             dataSize;
2964     const void*                        pData;
2965 } VkSpecializationInfo;
2966 
2967 typedef struct VkPipelineShaderStageCreateInfo {
2968     VkStructureType                     sType;
2969     const void*                         pNext;
2970     VkPipelineShaderStageCreateFlags    flags;
2971     VkShaderStageFlagBits               stage;
2972     VkShaderModule                      module;
2973     const char*                         pName;
2974     const VkSpecializationInfo*         pSpecializationInfo;
2975 } VkPipelineShaderStageCreateInfo;
2976 
2977 typedef struct VkComputePipelineCreateInfo {
2978     VkStructureType                    sType;
2979     const void*                        pNext;
2980     VkPipelineCreateFlags              flags;
2981     VkPipelineShaderStageCreateInfo    stage;
2982     VkPipelineLayout                   layout;
2983     VkPipeline                         basePipelineHandle;
2984     int32_t                            basePipelineIndex;
2985 } VkComputePipelineCreateInfo;
2986 
2987 typedef struct VkVertexInputBindingDescription {
2988     uint32_t             binding;
2989     uint32_t             stride;
2990     VkVertexInputRate    inputRate;
2991 } VkVertexInputBindingDescription;
2992 
2993 typedef struct VkVertexInputAttributeDescription {
2994     uint32_t    location;
2995     uint32_t    binding;
2996     VkFormat    format;
2997     uint32_t    offset;
2998 } VkVertexInputAttributeDescription;
2999 
3000 typedef struct VkPipelineVertexInputStateCreateInfo {
3001     VkStructureType                             sType;
3002     const void*                                 pNext;
3003     VkPipelineVertexInputStateCreateFlags       flags;
3004     uint32_t                                    vertexBindingDescriptionCount;
3005     const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
3006     uint32_t                                    vertexAttributeDescriptionCount;
3007     const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
3008 } VkPipelineVertexInputStateCreateInfo;
3009 
3010 typedef struct VkPipelineInputAssemblyStateCreateInfo {
3011     VkStructureType                            sType;
3012     const void*                                pNext;
3013     VkPipelineInputAssemblyStateCreateFlags    flags;
3014     VkPrimitiveTopology                        topology;
3015     VkBool32                                   primitiveRestartEnable;
3016 } VkPipelineInputAssemblyStateCreateInfo;
3017 
3018 typedef struct VkPipelineTessellationStateCreateInfo {
3019     VkStructureType                           sType;
3020     const void*                               pNext;
3021     VkPipelineTessellationStateCreateFlags    flags;
3022     uint32_t                                  patchControlPoints;
3023 } VkPipelineTessellationStateCreateInfo;
3024 
3025 typedef struct VkViewport {
3026     float    x;
3027     float    y;
3028     float    width;
3029     float    height;
3030     float    minDepth;
3031     float    maxDepth;
3032 } VkViewport;
3033 
3034 typedef struct VkPipelineViewportStateCreateInfo {
3035     VkStructureType                       sType;
3036     const void*                           pNext;
3037     VkPipelineViewportStateCreateFlags    flags;
3038     uint32_t                              viewportCount;
3039     const VkViewport*                     pViewports;
3040     uint32_t                              scissorCount;
3041     const VkRect2D*                       pScissors;
3042 } VkPipelineViewportStateCreateInfo;
3043 
3044 typedef struct VkPipelineRasterizationStateCreateInfo {
3045     VkStructureType                            sType;
3046     const void*                                pNext;
3047     VkPipelineRasterizationStateCreateFlags    flags;
3048     VkBool32                                   depthClampEnable;
3049     VkBool32                                   rasterizerDiscardEnable;
3050     VkPolygonMode                              polygonMode;
3051     VkCullModeFlags                            cullMode;
3052     VkFrontFace                                frontFace;
3053     VkBool32                                   depthBiasEnable;
3054     float                                      depthBiasConstantFactor;
3055     float                                      depthBiasClamp;
3056     float                                      depthBiasSlopeFactor;
3057     float                                      lineWidth;
3058 } VkPipelineRasterizationStateCreateInfo;
3059 
3060 typedef struct VkPipelineMultisampleStateCreateInfo {
3061     VkStructureType                          sType;
3062     const void*                              pNext;
3063     VkPipelineMultisampleStateCreateFlags    flags;
3064     VkSampleCountFlagBits                    rasterizationSamples;
3065     VkBool32                                 sampleShadingEnable;
3066     float                                    minSampleShading;
3067     const VkSampleMask*                      pSampleMask;
3068     VkBool32                                 alphaToCoverageEnable;
3069     VkBool32                                 alphaToOneEnable;
3070 } VkPipelineMultisampleStateCreateInfo;
3071 
3072 typedef struct VkStencilOpState {
3073     VkStencilOp    failOp;
3074     VkStencilOp    passOp;
3075     VkStencilOp    depthFailOp;
3076     VkCompareOp    compareOp;
3077     uint32_t       compareMask;
3078     uint32_t       writeMask;
3079     uint32_t       reference;
3080 } VkStencilOpState;
3081 
3082 typedef struct VkPipelineDepthStencilStateCreateInfo {
3083     VkStructureType                           sType;
3084     const void*                               pNext;
3085     VkPipelineDepthStencilStateCreateFlags    flags;
3086     VkBool32                                  depthTestEnable;
3087     VkBool32                                  depthWriteEnable;
3088     VkCompareOp                               depthCompareOp;
3089     VkBool32                                  depthBoundsTestEnable;
3090     VkBool32                                  stencilTestEnable;
3091     VkStencilOpState                          front;
3092     VkStencilOpState                          back;
3093     float                                     minDepthBounds;
3094     float                                     maxDepthBounds;
3095 } VkPipelineDepthStencilStateCreateInfo;
3096 
3097 typedef struct VkPipelineColorBlendAttachmentState {
3098     VkBool32                 blendEnable;
3099     VkBlendFactor            srcColorBlendFactor;
3100     VkBlendFactor            dstColorBlendFactor;
3101     VkBlendOp                colorBlendOp;
3102     VkBlendFactor            srcAlphaBlendFactor;
3103     VkBlendFactor            dstAlphaBlendFactor;
3104     VkBlendOp                alphaBlendOp;
3105     VkColorComponentFlags    colorWriteMask;
3106 } VkPipelineColorBlendAttachmentState;
3107 
3108 typedef struct VkPipelineColorBlendStateCreateInfo {
3109     VkStructureType                               sType;
3110     const void*                                   pNext;
3111     VkPipelineColorBlendStateCreateFlags          flags;
3112     VkBool32                                      logicOpEnable;
3113     VkLogicOp                                     logicOp;
3114     uint32_t                                      attachmentCount;
3115     const VkPipelineColorBlendAttachmentState*    pAttachments;
3116     float                                         blendConstants[4];
3117 } VkPipelineColorBlendStateCreateInfo;
3118 
3119 typedef struct VkPipelineDynamicStateCreateInfo {
3120     VkStructureType                      sType;
3121     const void*                          pNext;
3122     VkPipelineDynamicStateCreateFlags    flags;
3123     uint32_t                             dynamicStateCount;
3124     const VkDynamicState*                pDynamicStates;
3125 } VkPipelineDynamicStateCreateInfo;
3126 
3127 typedef struct VkGraphicsPipelineCreateInfo {
3128     VkStructureType                                  sType;
3129     const void*                                      pNext;
3130     VkPipelineCreateFlags                            flags;
3131     uint32_t                                         stageCount;
3132     const VkPipelineShaderStageCreateInfo*           pStages;
3133     const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
3134     const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
3135     const VkPipelineTessellationStateCreateInfo*     pTessellationState;
3136     const VkPipelineViewportStateCreateInfo*         pViewportState;
3137     const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
3138     const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
3139     const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
3140     const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
3141     const VkPipelineDynamicStateCreateInfo*          pDynamicState;
3142     VkPipelineLayout                                 layout;
3143     VkRenderPass                                     renderPass;
3144     uint32_t                                         subpass;
3145     VkPipeline                                       basePipelineHandle;
3146     int32_t                                          basePipelineIndex;
3147 } VkGraphicsPipelineCreateInfo;
3148 
3149 typedef struct VkPushConstantRange {
3150     VkShaderStageFlags    stageFlags;
3151     uint32_t              offset;
3152     uint32_t              size;
3153 } VkPushConstantRange;
3154 
3155 typedef struct VkPipelineLayoutCreateInfo {
3156     VkStructureType                 sType;
3157     const void*                     pNext;
3158     VkPipelineLayoutCreateFlags     flags;
3159     uint32_t                        setLayoutCount;
3160     const VkDescriptorSetLayout*    pSetLayouts;
3161     uint32_t                        pushConstantRangeCount;
3162     const VkPushConstantRange*      pPushConstantRanges;
3163 } VkPipelineLayoutCreateInfo;
3164 
3165 typedef struct VkSamplerCreateInfo {
3166     VkStructureType         sType;
3167     const void*             pNext;
3168     VkSamplerCreateFlags    flags;
3169     VkFilter                magFilter;
3170     VkFilter                minFilter;
3171     VkSamplerMipmapMode     mipmapMode;
3172     VkSamplerAddressMode    addressModeU;
3173     VkSamplerAddressMode    addressModeV;
3174     VkSamplerAddressMode    addressModeW;
3175     float                   mipLodBias;
3176     VkBool32                anisotropyEnable;
3177     float                   maxAnisotropy;
3178     VkBool32                compareEnable;
3179     VkCompareOp             compareOp;
3180     float                   minLod;
3181     float                   maxLod;
3182     VkBorderColor           borderColor;
3183     VkBool32                unnormalizedCoordinates;
3184 } VkSamplerCreateInfo;
3185 
3186 typedef struct VkCopyDescriptorSet {
3187     VkStructureType    sType;
3188     const void*        pNext;
3189     VkDescriptorSet    srcSet;
3190     uint32_t           srcBinding;
3191     uint32_t           srcArrayElement;
3192     VkDescriptorSet    dstSet;
3193     uint32_t           dstBinding;
3194     uint32_t           dstArrayElement;
3195     uint32_t           descriptorCount;
3196 } VkCopyDescriptorSet;
3197 
3198 typedef struct VkDescriptorBufferInfo {
3199     VkBuffer        buffer;
3200     VkDeviceSize    offset;
3201     VkDeviceSize    range;
3202 } VkDescriptorBufferInfo;
3203 
3204 typedef struct VkDescriptorImageInfo {
3205     VkSampler        sampler;
3206     VkImageView      imageView;
3207     VkImageLayout    imageLayout;
3208 } VkDescriptorImageInfo;
3209 
3210 typedef struct VkDescriptorPoolSize {
3211     VkDescriptorType    type;
3212     uint32_t            descriptorCount;
3213 } VkDescriptorPoolSize;
3214 
3215 typedef struct VkDescriptorPoolCreateInfo {
3216     VkStructureType                sType;
3217     const void*                    pNext;
3218     VkDescriptorPoolCreateFlags    flags;
3219     uint32_t                       maxSets;
3220     uint32_t                       poolSizeCount;
3221     const VkDescriptorPoolSize*    pPoolSizes;
3222 } VkDescriptorPoolCreateInfo;
3223 
3224 typedef struct VkDescriptorSetAllocateInfo {
3225     VkStructureType                 sType;
3226     const void*                     pNext;
3227     VkDescriptorPool                descriptorPool;
3228     uint32_t                        descriptorSetCount;
3229     const VkDescriptorSetLayout*    pSetLayouts;
3230 } VkDescriptorSetAllocateInfo;
3231 
3232 typedef struct VkDescriptorSetLayoutBinding {
3233     uint32_t              binding;
3234     VkDescriptorType      descriptorType;
3235     uint32_t              descriptorCount;
3236     VkShaderStageFlags    stageFlags;
3237     const VkSampler*      pImmutableSamplers;
3238 } VkDescriptorSetLayoutBinding;
3239 
3240 typedef struct VkDescriptorSetLayoutCreateInfo {
3241     VkStructureType                        sType;
3242     const void*                            pNext;
3243     VkDescriptorSetLayoutCreateFlags       flags;
3244     uint32_t                               bindingCount;
3245     const VkDescriptorSetLayoutBinding*    pBindings;
3246 } VkDescriptorSetLayoutCreateInfo;
3247 
3248 typedef struct VkWriteDescriptorSet {
3249     VkStructureType                  sType;
3250     const void*                      pNext;
3251     VkDescriptorSet                  dstSet;
3252     uint32_t                         dstBinding;
3253     uint32_t                         dstArrayElement;
3254     uint32_t                         descriptorCount;
3255     VkDescriptorType                 descriptorType;
3256     const VkDescriptorImageInfo*     pImageInfo;
3257     const VkDescriptorBufferInfo*    pBufferInfo;
3258     const VkBufferView*              pTexelBufferView;
3259 } VkWriteDescriptorSet;
3260 
3261 typedef struct VkAttachmentDescription {
3262     VkAttachmentDescriptionFlags    flags;
3263     VkFormat                        format;
3264     VkSampleCountFlagBits           samples;
3265     VkAttachmentLoadOp              loadOp;
3266     VkAttachmentStoreOp             storeOp;
3267     VkAttachmentLoadOp              stencilLoadOp;
3268     VkAttachmentStoreOp             stencilStoreOp;
3269     VkImageLayout                   initialLayout;
3270     VkImageLayout                   finalLayout;
3271 } VkAttachmentDescription;
3272 
3273 typedef struct VkAttachmentReference {
3274     uint32_t         attachment;
3275     VkImageLayout    layout;
3276 } VkAttachmentReference;
3277 
3278 typedef struct VkFramebufferCreateInfo {
3279     VkStructureType             sType;
3280     const void*                 pNext;
3281     VkFramebufferCreateFlags    flags;
3282     VkRenderPass                renderPass;
3283     uint32_t                    attachmentCount;
3284     const VkImageView*          pAttachments;
3285     uint32_t                    width;
3286     uint32_t                    height;
3287     uint32_t                    layers;
3288 } VkFramebufferCreateInfo;
3289 
3290 typedef struct VkSubpassDescription {
3291     VkSubpassDescriptionFlags       flags;
3292     VkPipelineBindPoint             pipelineBindPoint;
3293     uint32_t                        inputAttachmentCount;
3294     const VkAttachmentReference*    pInputAttachments;
3295     uint32_t                        colorAttachmentCount;
3296     const VkAttachmentReference*    pColorAttachments;
3297     const VkAttachmentReference*    pResolveAttachments;
3298     const VkAttachmentReference*    pDepthStencilAttachment;
3299     uint32_t                        preserveAttachmentCount;
3300     const uint32_t*                 pPreserveAttachments;
3301 } VkSubpassDescription;
3302 
3303 typedef struct VkSubpassDependency {
3304     uint32_t                srcSubpass;
3305     uint32_t                dstSubpass;
3306     VkPipelineStageFlags    srcStageMask;
3307     VkPipelineStageFlags    dstStageMask;
3308     VkAccessFlags           srcAccessMask;
3309     VkAccessFlags           dstAccessMask;
3310     VkDependencyFlags       dependencyFlags;
3311 } VkSubpassDependency;
3312 
3313 typedef struct VkRenderPassCreateInfo {
3314     VkStructureType                   sType;
3315     const void*                       pNext;
3316     VkRenderPassCreateFlags           flags;
3317     uint32_t                          attachmentCount;
3318     const VkAttachmentDescription*    pAttachments;
3319     uint32_t                          subpassCount;
3320     const VkSubpassDescription*       pSubpasses;
3321     uint32_t                          dependencyCount;
3322     const VkSubpassDependency*        pDependencies;
3323 } VkRenderPassCreateInfo;
3324 
3325 typedef struct VkCommandPoolCreateInfo {
3326     VkStructureType             sType;
3327     const void*                 pNext;
3328     VkCommandPoolCreateFlags    flags;
3329     uint32_t                    queueFamilyIndex;
3330 } VkCommandPoolCreateInfo;
3331 
3332 typedef struct VkCommandBufferAllocateInfo {
3333     VkStructureType         sType;
3334     const void*             pNext;
3335     VkCommandPool           commandPool;
3336     VkCommandBufferLevel    level;
3337     uint32_t                commandBufferCount;
3338 } VkCommandBufferAllocateInfo;
3339 
3340 typedef struct VkCommandBufferInheritanceInfo {
3341     VkStructureType                  sType;
3342     const void*                      pNext;
3343     VkRenderPass                     renderPass;
3344     uint32_t                         subpass;
3345     VkFramebuffer                    framebuffer;
3346     VkBool32                         occlusionQueryEnable;
3347     VkQueryControlFlags              queryFlags;
3348     VkQueryPipelineStatisticFlags    pipelineStatistics;
3349 } VkCommandBufferInheritanceInfo;
3350 
3351 typedef struct VkCommandBufferBeginInfo {
3352     VkStructureType                          sType;
3353     const void*                              pNext;
3354     VkCommandBufferUsageFlags                flags;
3355     const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
3356 } VkCommandBufferBeginInfo;
3357 
3358 typedef struct VkBufferCopy {
3359     VkDeviceSize    srcOffset;
3360     VkDeviceSize    dstOffset;
3361     VkDeviceSize    size;
3362 } VkBufferCopy;
3363 
3364 typedef struct VkImageSubresourceLayers {
3365     VkImageAspectFlags    aspectMask;
3366     uint32_t              mipLevel;
3367     uint32_t              baseArrayLayer;
3368     uint32_t              layerCount;
3369 } VkImageSubresourceLayers;
3370 
3371 typedef struct VkBufferImageCopy {
3372     VkDeviceSize                bufferOffset;
3373     uint32_t                    bufferRowLength;
3374     uint32_t                    bufferImageHeight;
3375     VkImageSubresourceLayers    imageSubresource;
3376     VkOffset3D                  imageOffset;
3377     VkExtent3D                  imageExtent;
3378 } VkBufferImageCopy;
3379 
3380 typedef union VkClearColorValue {
3381     float       float32[4];
3382     int32_t     int32[4];
3383     uint32_t    uint32[4];
3384 } VkClearColorValue;
3385 
3386 typedef struct VkClearDepthStencilValue {
3387     float       depth;
3388     uint32_t    stencil;
3389 } VkClearDepthStencilValue;
3390 
3391 typedef union VkClearValue {
3392     VkClearColorValue           color;
3393     VkClearDepthStencilValue    depthStencil;
3394 } VkClearValue;
3395 
3396 typedef struct VkClearAttachment {
3397     VkImageAspectFlags    aspectMask;
3398     uint32_t              colorAttachment;
3399     VkClearValue          clearValue;
3400 } VkClearAttachment;
3401 
3402 typedef struct VkClearRect {
3403     VkRect2D    rect;
3404     uint32_t    baseArrayLayer;
3405     uint32_t    layerCount;
3406 } VkClearRect;
3407 
3408 typedef struct VkImageBlit {
3409     VkImageSubresourceLayers    srcSubresource;
3410     VkOffset3D                  srcOffsets[2];
3411     VkImageSubresourceLayers    dstSubresource;
3412     VkOffset3D                  dstOffsets[2];
3413 } VkImageBlit;
3414 
3415 typedef struct VkImageCopy {
3416     VkImageSubresourceLayers    srcSubresource;
3417     VkOffset3D                  srcOffset;
3418     VkImageSubresourceLayers    dstSubresource;
3419     VkOffset3D                  dstOffset;
3420     VkExtent3D                  extent;
3421 } VkImageCopy;
3422 
3423 typedef struct VkImageResolve {
3424     VkImageSubresourceLayers    srcSubresource;
3425     VkOffset3D                  srcOffset;
3426     VkImageSubresourceLayers    dstSubresource;
3427     VkOffset3D                  dstOffset;
3428     VkExtent3D                  extent;
3429 } VkImageResolve;
3430 
3431 typedef struct VkRenderPassBeginInfo {
3432     VkStructureType        sType;
3433     const void*            pNext;
3434     VkRenderPass           renderPass;
3435     VkFramebuffer          framebuffer;
3436     VkRect2D               renderArea;
3437     uint32_t               clearValueCount;
3438     const VkClearValue*    pClearValues;
3439 } VkRenderPassBeginInfo;
3440 
3441 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
3442 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
3443 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
3444 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
3445 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
3446 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
3447 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
3448 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
3449 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
3450 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
3451 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
3452 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
3453 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
3454 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
3455 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
3456 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
3457 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
3458 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
3459 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
3460 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
3461 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
3462 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
3463 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
3464 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
3465 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
3466 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3467 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3468 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
3469 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3470 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3471 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
3472 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
3473 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
3474 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
3475 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
3476 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
3477 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
3478 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
3479 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
3480 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
3481 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
3482 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
3483 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
3484 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
3485 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
3486 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
3487 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
3488 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
3489 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
3490 typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
3491 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
3492 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
3493 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
3494 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
3495 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
3496 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
3497 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
3498 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
3499 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
3500 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
3501 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
3502 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
3503 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
3504 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
3505 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
3506 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3507 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3508 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
3509 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
3510 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
3511 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
3512 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
3513 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
3514 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
3515 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
3516 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
3517 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
3518 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
3519 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
3520 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
3521 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
3522 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
3523 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
3524 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
3525 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
3526 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
3527 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
3528 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
3529 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
3530 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3531 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
3532 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
3533 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
3534 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
3535 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
3536 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
3537 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
3538 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
3539 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
3540 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
3541 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
3542 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
3543 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
3544 typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
3545 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
3546 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
3547 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
3548 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
3549 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3550 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3551 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
3552 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
3553 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
3554 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
3555 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
3556 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3557 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3558 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
3559 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
3560 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3561 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3562 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
3563 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
3564 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3565 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3566 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
3567 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
3568 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
3569 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
3570 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
3571 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
3572 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
3573 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
3574 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
3575 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
3576 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
3577 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3578 
3579 #ifndef VK_NO_PROTOTYPES
3580 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
3581     const VkInstanceCreateInfo*                 pCreateInfo,
3582     const VkAllocationCallbacks*                pAllocator,
3583     VkInstance*                                 pInstance);
3584 
3585 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
3586     VkInstance                                  instance,
3587     const VkAllocationCallbacks*                pAllocator);
3588 
3589 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
3590     VkInstance                                  instance,
3591     uint32_t*                                   pPhysicalDeviceCount,
3592     VkPhysicalDevice*                           pPhysicalDevices);
3593 
3594 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
3595     VkPhysicalDevice                            physicalDevice,
3596     VkPhysicalDeviceFeatures*                   pFeatures);
3597 
3598 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
3599     VkPhysicalDevice                            physicalDevice,
3600     VkFormat                                    format,
3601     VkFormatProperties*                         pFormatProperties);
3602 
3603 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
3604     VkPhysicalDevice                            physicalDevice,
3605     VkFormat                                    format,
3606     VkImageType                                 type,
3607     VkImageTiling                               tiling,
3608     VkImageUsageFlags                           usage,
3609     VkImageCreateFlags                          flags,
3610     VkImageFormatProperties*                    pImageFormatProperties);
3611 
3612 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
3613     VkPhysicalDevice                            physicalDevice,
3614     VkPhysicalDeviceProperties*                 pProperties);
3615 
3616 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
3617     VkPhysicalDevice                            physicalDevice,
3618     uint32_t*                                   pQueueFamilyPropertyCount,
3619     VkQueueFamilyProperties*                    pQueueFamilyProperties);
3620 
3621 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
3622     VkPhysicalDevice                            physicalDevice,
3623     VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
3624 
3625 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
3626     VkInstance                                  instance,
3627     const char*                                 pName);
3628 
3629 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
3630     VkDevice                                    device,
3631     const char*                                 pName);
3632 
3633 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
3634     VkPhysicalDevice                            physicalDevice,
3635     const VkDeviceCreateInfo*                   pCreateInfo,
3636     const VkAllocationCallbacks*                pAllocator,
3637     VkDevice*                                   pDevice);
3638 
3639 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
3640     VkDevice                                    device,
3641     const VkAllocationCallbacks*                pAllocator);
3642 
3643 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
3644     const char*                                 pLayerName,
3645     uint32_t*                                   pPropertyCount,
3646     VkExtensionProperties*                      pProperties);
3647 
3648 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
3649     VkPhysicalDevice                            physicalDevice,
3650     const char*                                 pLayerName,
3651     uint32_t*                                   pPropertyCount,
3652     VkExtensionProperties*                      pProperties);
3653 
3654 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
3655     uint32_t*                                   pPropertyCount,
3656     VkLayerProperties*                          pProperties);
3657 
3658 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
3659     VkPhysicalDevice                            physicalDevice,
3660     uint32_t*                                   pPropertyCount,
3661     VkLayerProperties*                          pProperties);
3662 
3663 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
3664     VkDevice                                    device,
3665     uint32_t                                    queueFamilyIndex,
3666     uint32_t                                    queueIndex,
3667     VkQueue*                                    pQueue);
3668 
3669 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
3670     VkQueue                                     queue,
3671     uint32_t                                    submitCount,
3672     const VkSubmitInfo*                         pSubmits,
3673     VkFence                                     fence);
3674 
3675 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
3676     VkQueue                                     queue);
3677 
3678 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
3679     VkDevice                                    device);
3680 
3681 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
3682     VkDevice                                    device,
3683     const VkMemoryAllocateInfo*                 pAllocateInfo,
3684     const VkAllocationCallbacks*                pAllocator,
3685     VkDeviceMemory*                             pMemory);
3686 
3687 VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
3688     VkDevice                                    device,
3689     VkDeviceMemory                              memory,
3690     const VkAllocationCallbacks*                pAllocator);
3691 
3692 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
3693     VkDevice                                    device,
3694     VkDeviceMemory                              memory,
3695     VkDeviceSize                                offset,
3696     VkDeviceSize                                size,
3697     VkMemoryMapFlags                            flags,
3698     void**                                      ppData);
3699 
3700 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
3701     VkDevice                                    device,
3702     VkDeviceMemory                              memory);
3703 
3704 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
3705     VkDevice                                    device,
3706     uint32_t                                    memoryRangeCount,
3707     const VkMappedMemoryRange*                  pMemoryRanges);
3708 
3709 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
3710     VkDevice                                    device,
3711     uint32_t                                    memoryRangeCount,
3712     const VkMappedMemoryRange*                  pMemoryRanges);
3713 
3714 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
3715     VkDevice                                    device,
3716     VkDeviceMemory                              memory,
3717     VkDeviceSize*                               pCommittedMemoryInBytes);
3718 
3719 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
3720     VkDevice                                    device,
3721     VkBuffer                                    buffer,
3722     VkDeviceMemory                              memory,
3723     VkDeviceSize                                memoryOffset);
3724 
3725 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
3726     VkDevice                                    device,
3727     VkImage                                     image,
3728     VkDeviceMemory                              memory,
3729     VkDeviceSize                                memoryOffset);
3730 
3731 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
3732     VkDevice                                    device,
3733     VkBuffer                                    buffer,
3734     VkMemoryRequirements*                       pMemoryRequirements);
3735 
3736 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
3737     VkDevice                                    device,
3738     VkImage                                     image,
3739     VkMemoryRequirements*                       pMemoryRequirements);
3740 
3741 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
3742     VkDevice                                    device,
3743     VkImage                                     image,
3744     uint32_t*                                   pSparseMemoryRequirementCount,
3745     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
3746 
3747 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
3748     VkPhysicalDevice                            physicalDevice,
3749     VkFormat                                    format,
3750     VkImageType                                 type,
3751     VkSampleCountFlagBits                       samples,
3752     VkImageUsageFlags                           usage,
3753     VkImageTiling                               tiling,
3754     uint32_t*                                   pPropertyCount,
3755     VkSparseImageFormatProperties*              pProperties);
3756 
3757 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
3758     VkQueue                                     queue,
3759     uint32_t                                    bindInfoCount,
3760     const VkBindSparseInfo*                     pBindInfo,
3761     VkFence                                     fence);
3762 
3763 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
3764     VkDevice                                    device,
3765     const VkFenceCreateInfo*                    pCreateInfo,
3766     const VkAllocationCallbacks*                pAllocator,
3767     VkFence*                                    pFence);
3768 
3769 VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
3770     VkDevice                                    device,
3771     VkFence                                     fence,
3772     const VkAllocationCallbacks*                pAllocator);
3773 
3774 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
3775     VkDevice                                    device,
3776     uint32_t                                    fenceCount,
3777     const VkFence*                              pFences);
3778 
3779 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
3780     VkDevice                                    device,
3781     VkFence                                     fence);
3782 
3783 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
3784     VkDevice                                    device,
3785     uint32_t                                    fenceCount,
3786     const VkFence*                              pFences,
3787     VkBool32                                    waitAll,
3788     uint64_t                                    timeout);
3789 
3790 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
3791     VkDevice                                    device,
3792     const VkSemaphoreCreateInfo*                pCreateInfo,
3793     const VkAllocationCallbacks*                pAllocator,
3794     VkSemaphore*                                pSemaphore);
3795 
3796 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
3797     VkDevice                                    device,
3798     VkSemaphore                                 semaphore,
3799     const VkAllocationCallbacks*                pAllocator);
3800 
3801 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
3802     VkDevice                                    device,
3803     const VkEventCreateInfo*                    pCreateInfo,
3804     const VkAllocationCallbacks*                pAllocator,
3805     VkEvent*                                    pEvent);
3806 
3807 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
3808     VkDevice                                    device,
3809     VkEvent                                     event,
3810     const VkAllocationCallbacks*                pAllocator);
3811 
3812 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
3813     VkDevice                                    device,
3814     VkEvent                                     event);
3815 
3816 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
3817     VkDevice                                    device,
3818     VkEvent                                     event);
3819 
3820 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
3821     VkDevice                                    device,
3822     VkEvent                                     event);
3823 
3824 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
3825     VkDevice                                    device,
3826     const VkQueryPoolCreateInfo*                pCreateInfo,
3827     const VkAllocationCallbacks*                pAllocator,
3828     VkQueryPool*                                pQueryPool);
3829 
3830 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
3831     VkDevice                                    device,
3832     VkQueryPool                                 queryPool,
3833     const VkAllocationCallbacks*                pAllocator);
3834 
3835 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
3836     VkDevice                                    device,
3837     VkQueryPool                                 queryPool,
3838     uint32_t                                    firstQuery,
3839     uint32_t                                    queryCount,
3840     size_t                                      dataSize,
3841     void*                                       pData,
3842     VkDeviceSize                                stride,
3843     VkQueryResultFlags                          flags);
3844 
3845 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
3846     VkDevice                                    device,
3847     const VkBufferCreateInfo*                   pCreateInfo,
3848     const VkAllocationCallbacks*                pAllocator,
3849     VkBuffer*                                   pBuffer);
3850 
3851 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
3852     VkDevice                                    device,
3853     VkBuffer                                    buffer,
3854     const VkAllocationCallbacks*                pAllocator);
3855 
3856 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
3857     VkDevice                                    device,
3858     const VkBufferViewCreateInfo*               pCreateInfo,
3859     const VkAllocationCallbacks*                pAllocator,
3860     VkBufferView*                               pView);
3861 
3862 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
3863     VkDevice                                    device,
3864     VkBufferView                                bufferView,
3865     const VkAllocationCallbacks*                pAllocator);
3866 
3867 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
3868     VkDevice                                    device,
3869     const VkImageCreateInfo*                    pCreateInfo,
3870     const VkAllocationCallbacks*                pAllocator,
3871     VkImage*                                    pImage);
3872 
3873 VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
3874     VkDevice                                    device,
3875     VkImage                                     image,
3876     const VkAllocationCallbacks*                pAllocator);
3877 
3878 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
3879     VkDevice                                    device,
3880     VkImage                                     image,
3881     const VkImageSubresource*                   pSubresource,
3882     VkSubresourceLayout*                        pLayout);
3883 
3884 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
3885     VkDevice                                    device,
3886     const VkImageViewCreateInfo*                pCreateInfo,
3887     const VkAllocationCallbacks*                pAllocator,
3888     VkImageView*                                pView);
3889 
3890 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
3891     VkDevice                                    device,
3892     VkImageView                                 imageView,
3893     const VkAllocationCallbacks*                pAllocator);
3894 
3895 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
3896     VkDevice                                    device,
3897     const VkShaderModuleCreateInfo*             pCreateInfo,
3898     const VkAllocationCallbacks*                pAllocator,
3899     VkShaderModule*                             pShaderModule);
3900 
3901 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
3902     VkDevice                                    device,
3903     VkShaderModule                              shaderModule,
3904     const VkAllocationCallbacks*                pAllocator);
3905 
3906 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
3907     VkDevice                                    device,
3908     const VkPipelineCacheCreateInfo*            pCreateInfo,
3909     const VkAllocationCallbacks*                pAllocator,
3910     VkPipelineCache*                            pPipelineCache);
3911 
3912 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
3913     VkDevice                                    device,
3914     VkPipelineCache                             pipelineCache,
3915     const VkAllocationCallbacks*                pAllocator);
3916 
3917 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
3918     VkDevice                                    device,
3919     VkPipelineCache                             pipelineCache,
3920     size_t*                                     pDataSize,
3921     void*                                       pData);
3922 
3923 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
3924     VkDevice                                    device,
3925     VkPipelineCache                             dstCache,
3926     uint32_t                                    srcCacheCount,
3927     const VkPipelineCache*                      pSrcCaches);
3928 
3929 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
3930     VkDevice                                    device,
3931     VkPipelineCache                             pipelineCache,
3932     uint32_t                                    createInfoCount,
3933     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
3934     const VkAllocationCallbacks*                pAllocator,
3935     VkPipeline*                                 pPipelines);
3936 
3937 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
3938     VkDevice                                    device,
3939     VkPipelineCache                             pipelineCache,
3940     uint32_t                                    createInfoCount,
3941     const VkComputePipelineCreateInfo*          pCreateInfos,
3942     const VkAllocationCallbacks*                pAllocator,
3943     VkPipeline*                                 pPipelines);
3944 
3945 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
3946     VkDevice                                    device,
3947     VkPipeline                                  pipeline,
3948     const VkAllocationCallbacks*                pAllocator);
3949 
3950 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
3951     VkDevice                                    device,
3952     const VkPipelineLayoutCreateInfo*           pCreateInfo,
3953     const VkAllocationCallbacks*                pAllocator,
3954     VkPipelineLayout*                           pPipelineLayout);
3955 
3956 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
3957     VkDevice                                    device,
3958     VkPipelineLayout                            pipelineLayout,
3959     const VkAllocationCallbacks*                pAllocator);
3960 
3961 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
3962     VkDevice                                    device,
3963     const VkSamplerCreateInfo*                  pCreateInfo,
3964     const VkAllocationCallbacks*                pAllocator,
3965     VkSampler*                                  pSampler);
3966 
3967 VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
3968     VkDevice                                    device,
3969     VkSampler                                   sampler,
3970     const VkAllocationCallbacks*                pAllocator);
3971 
3972 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
3973     VkDevice                                    device,
3974     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
3975     const VkAllocationCallbacks*                pAllocator,
3976     VkDescriptorSetLayout*                      pSetLayout);
3977 
3978 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
3979     VkDevice                                    device,
3980     VkDescriptorSetLayout                       descriptorSetLayout,
3981     const VkAllocationCallbacks*                pAllocator);
3982 
3983 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
3984     VkDevice                                    device,
3985     const VkDescriptorPoolCreateInfo*           pCreateInfo,
3986     const VkAllocationCallbacks*                pAllocator,
3987     VkDescriptorPool*                           pDescriptorPool);
3988 
3989 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
3990     VkDevice                                    device,
3991     VkDescriptorPool                            descriptorPool,
3992     const VkAllocationCallbacks*                pAllocator);
3993 
3994 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
3995     VkDevice                                    device,
3996     VkDescriptorPool                            descriptorPool,
3997     VkDescriptorPoolResetFlags                  flags);
3998 
3999 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
4000     VkDevice                                    device,
4001     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
4002     VkDescriptorSet*                            pDescriptorSets);
4003 
4004 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
4005     VkDevice                                    device,
4006     VkDescriptorPool                            descriptorPool,
4007     uint32_t                                    descriptorSetCount,
4008     const VkDescriptorSet*                      pDescriptorSets);
4009 
4010 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
4011     VkDevice                                    device,
4012     uint32_t                                    descriptorWriteCount,
4013     const VkWriteDescriptorSet*                 pDescriptorWrites,
4014     uint32_t                                    descriptorCopyCount,
4015     const VkCopyDescriptorSet*                  pDescriptorCopies);
4016 
4017 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
4018     VkDevice                                    device,
4019     const VkFramebufferCreateInfo*              pCreateInfo,
4020     const VkAllocationCallbacks*                pAllocator,
4021     VkFramebuffer*                              pFramebuffer);
4022 
4023 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
4024     VkDevice                                    device,
4025     VkFramebuffer                               framebuffer,
4026     const VkAllocationCallbacks*                pAllocator);
4027 
4028 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
4029     VkDevice                                    device,
4030     const VkRenderPassCreateInfo*               pCreateInfo,
4031     const VkAllocationCallbacks*                pAllocator,
4032     VkRenderPass*                               pRenderPass);
4033 
4034 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
4035     VkDevice                                    device,
4036     VkRenderPass                                renderPass,
4037     const VkAllocationCallbacks*                pAllocator);
4038 
4039 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
4040     VkDevice                                    device,
4041     VkRenderPass                                renderPass,
4042     VkExtent2D*                                 pGranularity);
4043 
4044 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
4045     VkDevice                                    device,
4046     const VkCommandPoolCreateInfo*              pCreateInfo,
4047     const VkAllocationCallbacks*                pAllocator,
4048     VkCommandPool*                              pCommandPool);
4049 
4050 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
4051     VkDevice                                    device,
4052     VkCommandPool                               commandPool,
4053     const VkAllocationCallbacks*                pAllocator);
4054 
4055 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
4056     VkDevice                                    device,
4057     VkCommandPool                               commandPool,
4058     VkCommandPoolResetFlags                     flags);
4059 
4060 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
4061     VkDevice                                    device,
4062     const VkCommandBufferAllocateInfo*          pAllocateInfo,
4063     VkCommandBuffer*                            pCommandBuffers);
4064 
4065 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
4066     VkDevice                                    device,
4067     VkCommandPool                               commandPool,
4068     uint32_t                                    commandBufferCount,
4069     const VkCommandBuffer*                      pCommandBuffers);
4070 
4071 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
4072     VkCommandBuffer                             commandBuffer,
4073     const VkCommandBufferBeginInfo*             pBeginInfo);
4074 
4075 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
4076     VkCommandBuffer                             commandBuffer);
4077 
4078 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
4079     VkCommandBuffer                             commandBuffer,
4080     VkCommandBufferResetFlags                   flags);
4081 
4082 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
4083     VkCommandBuffer                             commandBuffer,
4084     VkPipelineBindPoint                         pipelineBindPoint,
4085     VkPipeline                                  pipeline);
4086 
4087 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
4088     VkCommandBuffer                             commandBuffer,
4089     uint32_t                                    firstViewport,
4090     uint32_t                                    viewportCount,
4091     const VkViewport*                           pViewports);
4092 
4093 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
4094     VkCommandBuffer                             commandBuffer,
4095     uint32_t                                    firstScissor,
4096     uint32_t                                    scissorCount,
4097     const VkRect2D*                             pScissors);
4098 
4099 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
4100     VkCommandBuffer                             commandBuffer,
4101     float                                       lineWidth);
4102 
4103 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
4104     VkCommandBuffer                             commandBuffer,
4105     float                                       depthBiasConstantFactor,
4106     float                                       depthBiasClamp,
4107     float                                       depthBiasSlopeFactor);
4108 
4109 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
4110     VkCommandBuffer                             commandBuffer,
4111     const float                                 blendConstants[4]);
4112 
4113 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
4114     VkCommandBuffer                             commandBuffer,
4115     float                                       minDepthBounds,
4116     float                                       maxDepthBounds);
4117 
4118 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
4119     VkCommandBuffer                             commandBuffer,
4120     VkStencilFaceFlags                          faceMask,
4121     uint32_t                                    compareMask);
4122 
4123 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
4124     VkCommandBuffer                             commandBuffer,
4125     VkStencilFaceFlags                          faceMask,
4126     uint32_t                                    writeMask);
4127 
4128 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
4129     VkCommandBuffer                             commandBuffer,
4130     VkStencilFaceFlags                          faceMask,
4131     uint32_t                                    reference);
4132 
4133 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
4134     VkCommandBuffer                             commandBuffer,
4135     VkPipelineBindPoint                         pipelineBindPoint,
4136     VkPipelineLayout                            layout,
4137     uint32_t                                    firstSet,
4138     uint32_t                                    descriptorSetCount,
4139     const VkDescriptorSet*                      pDescriptorSets,
4140     uint32_t                                    dynamicOffsetCount,
4141     const uint32_t*                             pDynamicOffsets);
4142 
4143 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
4144     VkCommandBuffer                             commandBuffer,
4145     VkBuffer                                    buffer,
4146     VkDeviceSize                                offset,
4147     VkIndexType                                 indexType);
4148 
4149 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
4150     VkCommandBuffer                             commandBuffer,
4151     uint32_t                                    firstBinding,
4152     uint32_t                                    bindingCount,
4153     const VkBuffer*                             pBuffers,
4154     const VkDeviceSize*                         pOffsets);
4155 
4156 VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
4157     VkCommandBuffer                             commandBuffer,
4158     uint32_t                                    vertexCount,
4159     uint32_t                                    instanceCount,
4160     uint32_t                                    firstVertex,
4161     uint32_t                                    firstInstance);
4162 
4163 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
4164     VkCommandBuffer                             commandBuffer,
4165     uint32_t                                    indexCount,
4166     uint32_t                                    instanceCount,
4167     uint32_t                                    firstIndex,
4168     int32_t                                     vertexOffset,
4169     uint32_t                                    firstInstance);
4170 
4171 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
4172     VkCommandBuffer                             commandBuffer,
4173     VkBuffer                                    buffer,
4174     VkDeviceSize                                offset,
4175     uint32_t                                    drawCount,
4176     uint32_t                                    stride);
4177 
4178 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
4179     VkCommandBuffer                             commandBuffer,
4180     VkBuffer                                    buffer,
4181     VkDeviceSize                                offset,
4182     uint32_t                                    drawCount,
4183     uint32_t                                    stride);
4184 
4185 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
4186     VkCommandBuffer                             commandBuffer,
4187     uint32_t                                    groupCountX,
4188     uint32_t                                    groupCountY,
4189     uint32_t                                    groupCountZ);
4190 
4191 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
4192     VkCommandBuffer                             commandBuffer,
4193     VkBuffer                                    buffer,
4194     VkDeviceSize                                offset);
4195 
4196 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
4197     VkCommandBuffer                             commandBuffer,
4198     VkBuffer                                    srcBuffer,
4199     VkBuffer                                    dstBuffer,
4200     uint32_t                                    regionCount,
4201     const VkBufferCopy*                         pRegions);
4202 
4203 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
4204     VkCommandBuffer                             commandBuffer,
4205     VkImage                                     srcImage,
4206     VkImageLayout                               srcImageLayout,
4207     VkImage                                     dstImage,
4208     VkImageLayout                               dstImageLayout,
4209     uint32_t                                    regionCount,
4210     const VkImageCopy*                          pRegions);
4211 
4212 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
4213     VkCommandBuffer                             commandBuffer,
4214     VkImage                                     srcImage,
4215     VkImageLayout                               srcImageLayout,
4216     VkImage                                     dstImage,
4217     VkImageLayout                               dstImageLayout,
4218     uint32_t                                    regionCount,
4219     const VkImageBlit*                          pRegions,
4220     VkFilter                                    filter);
4221 
4222 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
4223     VkCommandBuffer                             commandBuffer,
4224     VkBuffer                                    srcBuffer,
4225     VkImage                                     dstImage,
4226     VkImageLayout                               dstImageLayout,
4227     uint32_t                                    regionCount,
4228     const VkBufferImageCopy*                    pRegions);
4229 
4230 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
4231     VkCommandBuffer                             commandBuffer,
4232     VkImage                                     srcImage,
4233     VkImageLayout                               srcImageLayout,
4234     VkBuffer                                    dstBuffer,
4235     uint32_t                                    regionCount,
4236     const VkBufferImageCopy*                    pRegions);
4237 
4238 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
4239     VkCommandBuffer                             commandBuffer,
4240     VkBuffer                                    dstBuffer,
4241     VkDeviceSize                                dstOffset,
4242     VkDeviceSize                                dataSize,
4243     const void*                                 pData);
4244 
4245 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
4246     VkCommandBuffer                             commandBuffer,
4247     VkBuffer                                    dstBuffer,
4248     VkDeviceSize                                dstOffset,
4249     VkDeviceSize                                size,
4250     uint32_t                                    data);
4251 
4252 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
4253     VkCommandBuffer                             commandBuffer,
4254     VkImage                                     image,
4255     VkImageLayout                               imageLayout,
4256     const VkClearColorValue*                    pColor,
4257     uint32_t                                    rangeCount,
4258     const VkImageSubresourceRange*              pRanges);
4259 
4260 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
4261     VkCommandBuffer                             commandBuffer,
4262     VkImage                                     image,
4263     VkImageLayout                               imageLayout,
4264     const VkClearDepthStencilValue*             pDepthStencil,
4265     uint32_t                                    rangeCount,
4266     const VkImageSubresourceRange*              pRanges);
4267 
4268 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
4269     VkCommandBuffer                             commandBuffer,
4270     uint32_t                                    attachmentCount,
4271     const VkClearAttachment*                    pAttachments,
4272     uint32_t                                    rectCount,
4273     const VkClearRect*                          pRects);
4274 
4275 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
4276     VkCommandBuffer                             commandBuffer,
4277     VkImage                                     srcImage,
4278     VkImageLayout                               srcImageLayout,
4279     VkImage                                     dstImage,
4280     VkImageLayout                               dstImageLayout,
4281     uint32_t                                    regionCount,
4282     const VkImageResolve*                       pRegions);
4283 
4284 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
4285     VkCommandBuffer                             commandBuffer,
4286     VkEvent                                     event,
4287     VkPipelineStageFlags                        stageMask);
4288 
4289 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
4290     VkCommandBuffer                             commandBuffer,
4291     VkEvent                                     event,
4292     VkPipelineStageFlags                        stageMask);
4293 
4294 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
4295     VkCommandBuffer                             commandBuffer,
4296     uint32_t                                    eventCount,
4297     const VkEvent*                              pEvents,
4298     VkPipelineStageFlags                        srcStageMask,
4299     VkPipelineStageFlags                        dstStageMask,
4300     uint32_t                                    memoryBarrierCount,
4301     const VkMemoryBarrier*                      pMemoryBarriers,
4302     uint32_t                                    bufferMemoryBarrierCount,
4303     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
4304     uint32_t                                    imageMemoryBarrierCount,
4305     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
4306 
4307 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
4308     VkCommandBuffer                             commandBuffer,
4309     VkPipelineStageFlags                        srcStageMask,
4310     VkPipelineStageFlags                        dstStageMask,
4311     VkDependencyFlags                           dependencyFlags,
4312     uint32_t                                    memoryBarrierCount,
4313     const VkMemoryBarrier*                      pMemoryBarriers,
4314     uint32_t                                    bufferMemoryBarrierCount,
4315     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
4316     uint32_t                                    imageMemoryBarrierCount,
4317     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
4318 
4319 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
4320     VkCommandBuffer                             commandBuffer,
4321     VkQueryPool                                 queryPool,
4322     uint32_t                                    query,
4323     VkQueryControlFlags                         flags);
4324 
4325 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
4326     VkCommandBuffer                             commandBuffer,
4327     VkQueryPool                                 queryPool,
4328     uint32_t                                    query);
4329 
4330 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
4331     VkCommandBuffer                             commandBuffer,
4332     VkQueryPool                                 queryPool,
4333     uint32_t                                    firstQuery,
4334     uint32_t                                    queryCount);
4335 
4336 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
4337     VkCommandBuffer                             commandBuffer,
4338     VkPipelineStageFlagBits                     pipelineStage,
4339     VkQueryPool                                 queryPool,
4340     uint32_t                                    query);
4341 
4342 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
4343     VkCommandBuffer                             commandBuffer,
4344     VkQueryPool                                 queryPool,
4345     uint32_t                                    firstQuery,
4346     uint32_t                                    queryCount,
4347     VkBuffer                                    dstBuffer,
4348     VkDeviceSize                                dstOffset,
4349     VkDeviceSize                                stride,
4350     VkQueryResultFlags                          flags);
4351 
4352 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
4353     VkCommandBuffer                             commandBuffer,
4354     VkPipelineLayout                            layout,
4355     VkShaderStageFlags                          stageFlags,
4356     uint32_t                                    offset,
4357     uint32_t                                    size,
4358     const void*                                 pValues);
4359 
4360 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
4361     VkCommandBuffer                             commandBuffer,
4362     const VkRenderPassBeginInfo*                pRenderPassBegin,
4363     VkSubpassContents                           contents);
4364 
4365 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
4366     VkCommandBuffer                             commandBuffer,
4367     VkSubpassContents                           contents);
4368 
4369 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
4370     VkCommandBuffer                             commandBuffer);
4371 
4372 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
4373     VkCommandBuffer                             commandBuffer,
4374     uint32_t                                    commandBufferCount,
4375     const VkCommandBuffer*                      pCommandBuffers);
4376 #endif
4377 
4378 
4379 #define VK_VERSION_1_1 1
4380 // Vulkan 1.1 version number
4381 #define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0
4382 
4383 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)
4384 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)
4385 #define VK_MAX_DEVICE_GROUP_SIZE          32U
4386 #define VK_LUID_SIZE                      8U
4387 #define VK_QUEUE_FAMILY_EXTERNAL          (~1U)
4388 
4389 typedef enum VkPointClippingBehavior {
4390     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
4391     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
4392     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
4393     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
4394     VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
4395 } VkPointClippingBehavior;
4396 
4397 typedef enum VkTessellationDomainOrigin {
4398     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
4399     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
4400     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
4401     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
4402     VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
4403 } VkTessellationDomainOrigin;
4404 
4405 typedef enum VkSamplerYcbcrModelConversion {
4406     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
4407     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
4408     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,
4409     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,
4410     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
4411     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
4412     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
4413     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
4414     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
4415     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
4416     VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
4417 } VkSamplerYcbcrModelConversion;
4418 
4419 typedef enum VkSamplerYcbcrRange {
4420     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
4421     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
4422     VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
4423     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
4424     VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
4425 } VkSamplerYcbcrRange;
4426 
4427 typedef enum VkChromaLocation {
4428     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
4429     VK_CHROMA_LOCATION_MIDPOINT = 1,
4430     VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,
4431     VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,
4432     VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
4433 } VkChromaLocation;
4434 
4435 typedef enum VkDescriptorUpdateTemplateType {
4436     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
4437     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
4438     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
4439     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
4440 } VkDescriptorUpdateTemplateType;
4441 
4442 typedef enum VkSubgroupFeatureFlagBits {
4443     VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,
4444     VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,
4445     VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,
4446     VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,
4447     VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,
4448     VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,
4449     VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
4450     VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
4451     VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
4452     VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4453 } VkSubgroupFeatureFlagBits;
4454 typedef VkFlags VkSubgroupFeatureFlags;
4455 
4456 typedef enum VkPeerMemoryFeatureFlagBits {
4457     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001,
4458     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002,
4459     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004,
4460     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,
4461     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
4462     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
4463     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
4464     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
4465     VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4466 } VkPeerMemoryFeatureFlagBits;
4467 typedef VkFlags VkPeerMemoryFeatureFlags;
4468 
4469 typedef enum VkMemoryAllocateFlagBits {
4470     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
4471     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002,
4472     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004,
4473     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
4474     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
4475     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
4476     VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4477 } VkMemoryAllocateFlagBits;
4478 typedef VkFlags VkMemoryAllocateFlags;
4479 typedef VkFlags VkCommandPoolTrimFlags;
4480 typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;
4481 
4482 typedef enum VkExternalMemoryHandleTypeFlagBits {
4483     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4484     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4485     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4486     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,
4487     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,
4488     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,
4489     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,
4490     VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,
4491     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,
4492     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,
4493     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,
4494     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800,
4495     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
4496     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4497     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4498     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
4499     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
4500     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
4501     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
4502     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4503 } VkExternalMemoryHandleTypeFlagBits;
4504 typedef VkFlags VkExternalMemoryHandleTypeFlags;
4505 
4506 typedef enum VkExternalMemoryFeatureFlagBits {
4507     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,
4508     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,
4509     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,
4510     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
4511     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
4512     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
4513     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4514 } VkExternalMemoryFeatureFlagBits;
4515 typedef VkFlags VkExternalMemoryFeatureFlags;
4516 
4517 typedef enum VkExternalFenceHandleTypeFlagBits {
4518     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4519     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4520     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4521     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,
4522     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
4523     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4524     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4525     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
4526     VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4527 } VkExternalFenceHandleTypeFlagBits;
4528 typedef VkFlags VkExternalFenceHandleTypeFlags;
4529 
4530 typedef enum VkExternalFenceFeatureFlagBits {
4531     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001,
4532     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,
4533     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
4534     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
4535     VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4536 } VkExternalFenceFeatureFlagBits;
4537 typedef VkFlags VkExternalFenceFeatureFlags;
4538 
4539 typedef enum VkFenceImportFlagBits {
4540     VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,
4541     VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,
4542     VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4543 } VkFenceImportFlagBits;
4544 typedef VkFlags VkFenceImportFlags;
4545 
4546 typedef enum VkSemaphoreImportFlagBits {
4547     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,
4548     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
4549     VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4550 } VkSemaphoreImportFlagBits;
4551 typedef VkFlags VkSemaphoreImportFlags;
4552 
4553 typedef enum VkExternalSemaphoreHandleTypeFlagBits {
4554     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4555     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4556     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4557     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008,
4558     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,
4559     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080,
4560     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
4561     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
4562     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4563     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4564     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
4565     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
4566     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4567 } VkExternalSemaphoreHandleTypeFlagBits;
4568 typedef VkFlags VkExternalSemaphoreHandleTypeFlags;
4569 
4570 typedef enum VkExternalSemaphoreFeatureFlagBits {
4571     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001,
4572     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,
4573     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
4574     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
4575     VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4576 } VkExternalSemaphoreFeatureFlagBits;
4577 typedef VkFlags VkExternalSemaphoreFeatureFlags;
4578 typedef struct VkPhysicalDeviceSubgroupProperties {
4579     VkStructureType           sType;
4580     void*                     pNext;
4581     uint32_t                  subgroupSize;
4582     VkShaderStageFlags        supportedStages;
4583     VkSubgroupFeatureFlags    supportedOperations;
4584     VkBool32                  quadOperationsInAllStages;
4585 } VkPhysicalDeviceSubgroupProperties;
4586 
4587 typedef struct VkBindBufferMemoryInfo {
4588     VkStructureType    sType;
4589     const void*        pNext;
4590     VkBuffer           buffer;
4591     VkDeviceMemory     memory;
4592     VkDeviceSize       memoryOffset;
4593 } VkBindBufferMemoryInfo;
4594 
4595 typedef struct VkBindImageMemoryInfo {
4596     VkStructureType    sType;
4597     const void*        pNext;
4598     VkImage            image;
4599     VkDeviceMemory     memory;
4600     VkDeviceSize       memoryOffset;
4601 } VkBindImageMemoryInfo;
4602 
4603 typedef struct VkPhysicalDevice16BitStorageFeatures {
4604     VkStructureType    sType;
4605     void*              pNext;
4606     VkBool32           storageBuffer16BitAccess;
4607     VkBool32           uniformAndStorageBuffer16BitAccess;
4608     VkBool32           storagePushConstant16;
4609     VkBool32           storageInputOutput16;
4610 } VkPhysicalDevice16BitStorageFeatures;
4611 
4612 typedef struct VkMemoryDedicatedRequirements {
4613     VkStructureType    sType;
4614     void*              pNext;
4615     VkBool32           prefersDedicatedAllocation;
4616     VkBool32           requiresDedicatedAllocation;
4617 } VkMemoryDedicatedRequirements;
4618 
4619 typedef struct VkMemoryDedicatedAllocateInfo {
4620     VkStructureType    sType;
4621     const void*        pNext;
4622     VkImage            image;
4623     VkBuffer           buffer;
4624 } VkMemoryDedicatedAllocateInfo;
4625 
4626 typedef struct VkMemoryAllocateFlagsInfo {
4627     VkStructureType          sType;
4628     const void*              pNext;
4629     VkMemoryAllocateFlags    flags;
4630     uint32_t                 deviceMask;
4631 } VkMemoryAllocateFlagsInfo;
4632 
4633 typedef struct VkDeviceGroupRenderPassBeginInfo {
4634     VkStructureType    sType;
4635     const void*        pNext;
4636     uint32_t           deviceMask;
4637     uint32_t           deviceRenderAreaCount;
4638     const VkRect2D*    pDeviceRenderAreas;
4639 } VkDeviceGroupRenderPassBeginInfo;
4640 
4641 typedef struct VkDeviceGroupCommandBufferBeginInfo {
4642     VkStructureType    sType;
4643     const void*        pNext;
4644     uint32_t           deviceMask;
4645 } VkDeviceGroupCommandBufferBeginInfo;
4646 
4647 typedef struct VkDeviceGroupSubmitInfo {
4648     VkStructureType    sType;
4649     const void*        pNext;
4650     uint32_t           waitSemaphoreCount;
4651     const uint32_t*    pWaitSemaphoreDeviceIndices;
4652     uint32_t           commandBufferCount;
4653     const uint32_t*    pCommandBufferDeviceMasks;
4654     uint32_t           signalSemaphoreCount;
4655     const uint32_t*    pSignalSemaphoreDeviceIndices;
4656 } VkDeviceGroupSubmitInfo;
4657 
4658 typedef struct VkDeviceGroupBindSparseInfo {
4659     VkStructureType    sType;
4660     const void*        pNext;
4661     uint32_t           resourceDeviceIndex;
4662     uint32_t           memoryDeviceIndex;
4663 } VkDeviceGroupBindSparseInfo;
4664 
4665 typedef struct VkBindBufferMemoryDeviceGroupInfo {
4666     VkStructureType    sType;
4667     const void*        pNext;
4668     uint32_t           deviceIndexCount;
4669     const uint32_t*    pDeviceIndices;
4670 } VkBindBufferMemoryDeviceGroupInfo;
4671 
4672 typedef struct VkBindImageMemoryDeviceGroupInfo {
4673     VkStructureType    sType;
4674     const void*        pNext;
4675     uint32_t           deviceIndexCount;
4676     const uint32_t*    pDeviceIndices;
4677     uint32_t           splitInstanceBindRegionCount;
4678     const VkRect2D*    pSplitInstanceBindRegions;
4679 } VkBindImageMemoryDeviceGroupInfo;
4680 
4681 typedef struct VkPhysicalDeviceGroupProperties {
4682     VkStructureType     sType;
4683     void*               pNext;
4684     uint32_t            physicalDeviceCount;
4685     VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
4686     VkBool32            subsetAllocation;
4687 } VkPhysicalDeviceGroupProperties;
4688 
4689 typedef struct VkDeviceGroupDeviceCreateInfo {
4690     VkStructureType            sType;
4691     const void*                pNext;
4692     uint32_t                   physicalDeviceCount;
4693     const VkPhysicalDevice*    pPhysicalDevices;
4694 } VkDeviceGroupDeviceCreateInfo;
4695 
4696 typedef struct VkBufferMemoryRequirementsInfo2 {
4697     VkStructureType    sType;
4698     const void*        pNext;
4699     VkBuffer           buffer;
4700 } VkBufferMemoryRequirementsInfo2;
4701 
4702 typedef struct VkImageMemoryRequirementsInfo2 {
4703     VkStructureType    sType;
4704     const void*        pNext;
4705     VkImage            image;
4706 } VkImageMemoryRequirementsInfo2;
4707 
4708 typedef struct VkImageSparseMemoryRequirementsInfo2 {
4709     VkStructureType    sType;
4710     const void*        pNext;
4711     VkImage            image;
4712 } VkImageSparseMemoryRequirementsInfo2;
4713 
4714 typedef struct VkMemoryRequirements2 {
4715     VkStructureType         sType;
4716     void*                   pNext;
4717     VkMemoryRequirements    memoryRequirements;
4718 } VkMemoryRequirements2;
4719 
4720 typedef struct VkSparseImageMemoryRequirements2 {
4721     VkStructureType                    sType;
4722     void*                              pNext;
4723     VkSparseImageMemoryRequirements    memoryRequirements;
4724 } VkSparseImageMemoryRequirements2;
4725 
4726 typedef struct VkPhysicalDeviceFeatures2 {
4727     VkStructureType             sType;
4728     void*                       pNext;
4729     VkPhysicalDeviceFeatures    features;
4730 } VkPhysicalDeviceFeatures2;
4731 
4732 typedef struct VkPhysicalDeviceProperties2 {
4733     VkStructureType               sType;
4734     void*                         pNext;
4735     VkPhysicalDeviceProperties    properties;
4736 } VkPhysicalDeviceProperties2;
4737 
4738 typedef struct VkFormatProperties2 {
4739     VkStructureType       sType;
4740     void*                 pNext;
4741     VkFormatProperties    formatProperties;
4742 } VkFormatProperties2;
4743 
4744 typedef struct VkImageFormatProperties2 {
4745     VkStructureType            sType;
4746     void*                      pNext;
4747     VkImageFormatProperties    imageFormatProperties;
4748 } VkImageFormatProperties2;
4749 
4750 typedef struct VkPhysicalDeviceImageFormatInfo2 {
4751     VkStructureType       sType;
4752     const void*           pNext;
4753     VkFormat              format;
4754     VkImageType           type;
4755     VkImageTiling         tiling;
4756     VkImageUsageFlags     usage;
4757     VkImageCreateFlags    flags;
4758 } VkPhysicalDeviceImageFormatInfo2;
4759 
4760 typedef struct VkQueueFamilyProperties2 {
4761     VkStructureType            sType;
4762     void*                      pNext;
4763     VkQueueFamilyProperties    queueFamilyProperties;
4764 } VkQueueFamilyProperties2;
4765 
4766 typedef struct VkPhysicalDeviceMemoryProperties2 {
4767     VkStructureType                     sType;
4768     void*                               pNext;
4769     VkPhysicalDeviceMemoryProperties    memoryProperties;
4770 } VkPhysicalDeviceMemoryProperties2;
4771 
4772 typedef struct VkSparseImageFormatProperties2 {
4773     VkStructureType                  sType;
4774     void*                            pNext;
4775     VkSparseImageFormatProperties    properties;
4776 } VkSparseImageFormatProperties2;
4777 
4778 typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {
4779     VkStructureType          sType;
4780     const void*              pNext;
4781     VkFormat                 format;
4782     VkImageType              type;
4783     VkSampleCountFlagBits    samples;
4784     VkImageUsageFlags        usage;
4785     VkImageTiling            tiling;
4786 } VkPhysicalDeviceSparseImageFormatInfo2;
4787 
4788 typedef struct VkPhysicalDevicePointClippingProperties {
4789     VkStructureType            sType;
4790     void*                      pNext;
4791     VkPointClippingBehavior    pointClippingBehavior;
4792 } VkPhysicalDevicePointClippingProperties;
4793 
4794 typedef struct VkInputAttachmentAspectReference {
4795     uint32_t              subpass;
4796     uint32_t              inputAttachmentIndex;
4797     VkImageAspectFlags    aspectMask;
4798 } VkInputAttachmentAspectReference;
4799 
4800 typedef struct VkRenderPassInputAttachmentAspectCreateInfo {
4801     VkStructureType                            sType;
4802     const void*                                pNext;
4803     uint32_t                                   aspectReferenceCount;
4804     const VkInputAttachmentAspectReference*    pAspectReferences;
4805 } VkRenderPassInputAttachmentAspectCreateInfo;
4806 
4807 typedef struct VkImageViewUsageCreateInfo {
4808     VkStructureType      sType;
4809     const void*          pNext;
4810     VkImageUsageFlags    usage;
4811 } VkImageViewUsageCreateInfo;
4812 
4813 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo {
4814     VkStructureType               sType;
4815     const void*                   pNext;
4816     VkTessellationDomainOrigin    domainOrigin;
4817 } VkPipelineTessellationDomainOriginStateCreateInfo;
4818 
4819 typedef struct VkRenderPassMultiviewCreateInfo {
4820     VkStructureType    sType;
4821     const void*        pNext;
4822     uint32_t           subpassCount;
4823     const uint32_t*    pViewMasks;
4824     uint32_t           dependencyCount;
4825     const int32_t*     pViewOffsets;
4826     uint32_t           correlationMaskCount;
4827     const uint32_t*    pCorrelationMasks;
4828 } VkRenderPassMultiviewCreateInfo;
4829 
4830 typedef struct VkPhysicalDeviceMultiviewFeatures {
4831     VkStructureType    sType;
4832     void*              pNext;
4833     VkBool32           multiview;
4834     VkBool32           multiviewGeometryShader;
4835     VkBool32           multiviewTessellationShader;
4836 } VkPhysicalDeviceMultiviewFeatures;
4837 
4838 typedef struct VkPhysicalDeviceMultiviewProperties {
4839     VkStructureType    sType;
4840     void*              pNext;
4841     uint32_t           maxMultiviewViewCount;
4842     uint32_t           maxMultiviewInstanceIndex;
4843 } VkPhysicalDeviceMultiviewProperties;
4844 
4845 typedef struct VkPhysicalDeviceVariablePointersFeatures {
4846     VkStructureType    sType;
4847     void*              pNext;
4848     VkBool32           variablePointersStorageBuffer;
4849     VkBool32           variablePointers;
4850 } VkPhysicalDeviceVariablePointersFeatures;
4851 
4852 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;
4853 
4854 typedef struct VkPhysicalDeviceProtectedMemoryFeatures {
4855     VkStructureType    sType;
4856     void*              pNext;
4857     VkBool32           protectedMemory;
4858 } VkPhysicalDeviceProtectedMemoryFeatures;
4859 
4860 typedef struct VkPhysicalDeviceProtectedMemoryProperties {
4861     VkStructureType    sType;
4862     void*              pNext;
4863     VkBool32           protectedNoFault;
4864 } VkPhysicalDeviceProtectedMemoryProperties;
4865 
4866 typedef struct VkDeviceQueueInfo2 {
4867     VkStructureType             sType;
4868     const void*                 pNext;
4869     VkDeviceQueueCreateFlags    flags;
4870     uint32_t                    queueFamilyIndex;
4871     uint32_t                    queueIndex;
4872 } VkDeviceQueueInfo2;
4873 
4874 typedef struct VkProtectedSubmitInfo {
4875     VkStructureType    sType;
4876     const void*        pNext;
4877     VkBool32           protectedSubmit;
4878 } VkProtectedSubmitInfo;
4879 
4880 typedef struct VkSamplerYcbcrConversionCreateInfo {
4881     VkStructureType                  sType;
4882     const void*                      pNext;
4883     VkFormat                         format;
4884     VkSamplerYcbcrModelConversion    ycbcrModel;
4885     VkSamplerYcbcrRange              ycbcrRange;
4886     VkComponentMapping               components;
4887     VkChromaLocation                 xChromaOffset;
4888     VkChromaLocation                 yChromaOffset;
4889     VkFilter                         chromaFilter;
4890     VkBool32                         forceExplicitReconstruction;
4891 } VkSamplerYcbcrConversionCreateInfo;
4892 
4893 typedef struct VkSamplerYcbcrConversionInfo {
4894     VkStructureType             sType;
4895     const void*                 pNext;
4896     VkSamplerYcbcrConversion    conversion;
4897 } VkSamplerYcbcrConversionInfo;
4898 
4899 typedef struct VkBindImagePlaneMemoryInfo {
4900     VkStructureType          sType;
4901     const void*              pNext;
4902     VkImageAspectFlagBits    planeAspect;
4903 } VkBindImagePlaneMemoryInfo;
4904 
4905 typedef struct VkImagePlaneMemoryRequirementsInfo {
4906     VkStructureType          sType;
4907     const void*              pNext;
4908     VkImageAspectFlagBits    planeAspect;
4909 } VkImagePlaneMemoryRequirementsInfo;
4910 
4911 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
4912     VkStructureType    sType;
4913     void*              pNext;
4914     VkBool32           samplerYcbcrConversion;
4915 } VkPhysicalDeviceSamplerYcbcrConversionFeatures;
4916 
4917 typedef struct VkSamplerYcbcrConversionImageFormatProperties {
4918     VkStructureType    sType;
4919     void*              pNext;
4920     uint32_t           combinedImageSamplerDescriptorCount;
4921 } VkSamplerYcbcrConversionImageFormatProperties;
4922 
4923 typedef struct VkDescriptorUpdateTemplateEntry {
4924     uint32_t            dstBinding;
4925     uint32_t            dstArrayElement;
4926     uint32_t            descriptorCount;
4927     VkDescriptorType    descriptorType;
4928     size_t              offset;
4929     size_t              stride;
4930 } VkDescriptorUpdateTemplateEntry;
4931 
4932 typedef struct VkDescriptorUpdateTemplateCreateInfo {
4933     VkStructureType                           sType;
4934     const void*                               pNext;
4935     VkDescriptorUpdateTemplateCreateFlags     flags;
4936     uint32_t                                  descriptorUpdateEntryCount;
4937     const VkDescriptorUpdateTemplateEntry*    pDescriptorUpdateEntries;
4938     VkDescriptorUpdateTemplateType            templateType;
4939     VkDescriptorSetLayout                     descriptorSetLayout;
4940     VkPipelineBindPoint                       pipelineBindPoint;
4941     VkPipelineLayout                          pipelineLayout;
4942     uint32_t                                  set;
4943 } VkDescriptorUpdateTemplateCreateInfo;
4944 
4945 typedef struct VkExternalMemoryProperties {
4946     VkExternalMemoryFeatureFlags       externalMemoryFeatures;
4947     VkExternalMemoryHandleTypeFlags    exportFromImportedHandleTypes;
4948     VkExternalMemoryHandleTypeFlags    compatibleHandleTypes;
4949 } VkExternalMemoryProperties;
4950 
4951 typedef struct VkPhysicalDeviceExternalImageFormatInfo {
4952     VkStructureType                       sType;
4953     const void*                           pNext;
4954     VkExternalMemoryHandleTypeFlagBits    handleType;
4955 } VkPhysicalDeviceExternalImageFormatInfo;
4956 
4957 typedef struct VkExternalImageFormatProperties {
4958     VkStructureType               sType;
4959     void*                         pNext;
4960     VkExternalMemoryProperties    externalMemoryProperties;
4961 } VkExternalImageFormatProperties;
4962 
4963 typedef struct VkPhysicalDeviceExternalBufferInfo {
4964     VkStructureType                       sType;
4965     const void*                           pNext;
4966     VkBufferCreateFlags                   flags;
4967     VkBufferUsageFlags                    usage;
4968     VkExternalMemoryHandleTypeFlagBits    handleType;
4969 } VkPhysicalDeviceExternalBufferInfo;
4970 
4971 typedef struct VkExternalBufferProperties {
4972     VkStructureType               sType;
4973     void*                         pNext;
4974     VkExternalMemoryProperties    externalMemoryProperties;
4975 } VkExternalBufferProperties;
4976 
4977 typedef struct VkPhysicalDeviceIDProperties {
4978     VkStructureType    sType;
4979     void*              pNext;
4980     uint8_t            deviceUUID[VK_UUID_SIZE];
4981     uint8_t            driverUUID[VK_UUID_SIZE];
4982     uint8_t            deviceLUID[VK_LUID_SIZE];
4983     uint32_t           deviceNodeMask;
4984     VkBool32           deviceLUIDValid;
4985 } VkPhysicalDeviceIDProperties;
4986 
4987 typedef struct VkExternalMemoryImageCreateInfo {
4988     VkStructureType                    sType;
4989     const void*                        pNext;
4990     VkExternalMemoryHandleTypeFlags    handleTypes;
4991 } VkExternalMemoryImageCreateInfo;
4992 
4993 typedef struct VkExternalMemoryBufferCreateInfo {
4994     VkStructureType                    sType;
4995     const void*                        pNext;
4996     VkExternalMemoryHandleTypeFlags    handleTypes;
4997 } VkExternalMemoryBufferCreateInfo;
4998 
4999 typedef struct VkExportMemoryAllocateInfo {
5000     VkStructureType                    sType;
5001     const void*                        pNext;
5002     VkExternalMemoryHandleTypeFlags    handleTypes;
5003 } VkExportMemoryAllocateInfo;
5004 
5005 typedef struct VkPhysicalDeviceExternalFenceInfo {
5006     VkStructureType                      sType;
5007     const void*                          pNext;
5008     VkExternalFenceHandleTypeFlagBits    handleType;
5009 } VkPhysicalDeviceExternalFenceInfo;
5010 
5011 typedef struct VkExternalFenceProperties {
5012     VkStructureType                   sType;
5013     void*                             pNext;
5014     VkExternalFenceHandleTypeFlags    exportFromImportedHandleTypes;
5015     VkExternalFenceHandleTypeFlags    compatibleHandleTypes;
5016     VkExternalFenceFeatureFlags       externalFenceFeatures;
5017 } VkExternalFenceProperties;
5018 
5019 typedef struct VkExportFenceCreateInfo {
5020     VkStructureType                   sType;
5021     const void*                       pNext;
5022     VkExternalFenceHandleTypeFlags    handleTypes;
5023 } VkExportFenceCreateInfo;
5024 
5025 typedef struct VkExportSemaphoreCreateInfo {
5026     VkStructureType                       sType;
5027     const void*                           pNext;
5028     VkExternalSemaphoreHandleTypeFlags    handleTypes;
5029 } VkExportSemaphoreCreateInfo;
5030 
5031 typedef struct VkPhysicalDeviceExternalSemaphoreInfo {
5032     VkStructureType                          sType;
5033     const void*                              pNext;
5034     VkExternalSemaphoreHandleTypeFlagBits    handleType;
5035 } VkPhysicalDeviceExternalSemaphoreInfo;
5036 
5037 typedef struct VkExternalSemaphoreProperties {
5038     VkStructureType                       sType;
5039     void*                                 pNext;
5040     VkExternalSemaphoreHandleTypeFlags    exportFromImportedHandleTypes;
5041     VkExternalSemaphoreHandleTypeFlags    compatibleHandleTypes;
5042     VkExternalSemaphoreFeatureFlags       externalSemaphoreFeatures;
5043 } VkExternalSemaphoreProperties;
5044 
5045 typedef struct VkPhysicalDeviceMaintenance3Properties {
5046     VkStructureType    sType;
5047     void*              pNext;
5048     uint32_t           maxPerSetDescriptors;
5049     VkDeviceSize       maxMemoryAllocationSize;
5050 } VkPhysicalDeviceMaintenance3Properties;
5051 
5052 typedef struct VkDescriptorSetLayoutSupport {
5053     VkStructureType    sType;
5054     void*              pNext;
5055     VkBool32           supported;
5056 } VkDescriptorSetLayoutSupport;
5057 
5058 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures {
5059     VkStructureType    sType;
5060     void*              pNext;
5061     VkBool32           shaderDrawParameters;
5062 } VkPhysicalDeviceShaderDrawParametersFeatures;
5063 
5064 typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;
5065 
5066 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion);
5067 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
5068 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
5069 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
5070 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
5071 typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
5072 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
5073 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
5074 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
5075 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
5076 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
5077 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
5078 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
5079 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
5080 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
5081 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
5082 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
5083 typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
5084 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
5085 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
5086 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
5087 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
5088 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
5089 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
5090 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
5091 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
5092 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
5093 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
5094 
5095 #ifndef VK_NO_PROTOTYPES
5096 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(
5097     uint32_t*                                   pApiVersion);
5098 
5099 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(
5100     VkDevice                                    device,
5101     uint32_t                                    bindInfoCount,
5102     const VkBindBufferMemoryInfo*               pBindInfos);
5103 
5104 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(
5105     VkDevice                                    device,
5106     uint32_t                                    bindInfoCount,
5107     const VkBindImageMemoryInfo*                pBindInfos);
5108 
5109 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(
5110     VkDevice                                    device,
5111     uint32_t                                    heapIndex,
5112     uint32_t                                    localDeviceIndex,
5113     uint32_t                                    remoteDeviceIndex,
5114     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
5115 
5116 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(
5117     VkCommandBuffer                             commandBuffer,
5118     uint32_t                                    deviceMask);
5119 
5120 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(
5121     VkCommandBuffer                             commandBuffer,
5122     uint32_t                                    baseGroupX,
5123     uint32_t                                    baseGroupY,
5124     uint32_t                                    baseGroupZ,
5125     uint32_t                                    groupCountX,
5126     uint32_t                                    groupCountY,
5127     uint32_t                                    groupCountZ);
5128 
5129 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(
5130     VkInstance                                  instance,
5131     uint32_t*                                   pPhysicalDeviceGroupCount,
5132     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
5133 
5134 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(
5135     VkDevice                                    device,
5136     const VkImageMemoryRequirementsInfo2*       pInfo,
5137     VkMemoryRequirements2*                      pMemoryRequirements);
5138 
5139 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(
5140     VkDevice                                    device,
5141     const VkBufferMemoryRequirementsInfo2*      pInfo,
5142     VkMemoryRequirements2*                      pMemoryRequirements);
5143 
5144 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(
5145     VkDevice                                    device,
5146     const VkImageSparseMemoryRequirementsInfo2* pInfo,
5147     uint32_t*                                   pSparseMemoryRequirementCount,
5148     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
5149 
5150 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(
5151     VkPhysicalDevice                            physicalDevice,
5152     VkPhysicalDeviceFeatures2*                  pFeatures);
5153 
5154 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(
5155     VkPhysicalDevice                            physicalDevice,
5156     VkPhysicalDeviceProperties2*                pProperties);
5157 
5158 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(
5159     VkPhysicalDevice                            physicalDevice,
5160     VkFormat                                    format,
5161     VkFormatProperties2*                        pFormatProperties);
5162 
5163 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(
5164     VkPhysicalDevice                            physicalDevice,
5165     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
5166     VkImageFormatProperties2*                   pImageFormatProperties);
5167 
5168 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(
5169     VkPhysicalDevice                            physicalDevice,
5170     uint32_t*                                   pQueueFamilyPropertyCount,
5171     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
5172 
5173 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(
5174     VkPhysicalDevice                            physicalDevice,
5175     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
5176 
5177 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(
5178     VkPhysicalDevice                            physicalDevice,
5179     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
5180     uint32_t*                                   pPropertyCount,
5181     VkSparseImageFormatProperties2*             pProperties);
5182 
5183 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(
5184     VkDevice                                    device,
5185     VkCommandPool                               commandPool,
5186     VkCommandPoolTrimFlags                      flags);
5187 
5188 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(
5189     VkDevice                                    device,
5190     const VkDeviceQueueInfo2*                   pQueueInfo,
5191     VkQueue*                                    pQueue);
5192 
5193 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(
5194     VkDevice                                    device,
5195     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
5196     const VkAllocationCallbacks*                pAllocator,
5197     VkSamplerYcbcrConversion*                   pYcbcrConversion);
5198 
5199 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(
5200     VkDevice                                    device,
5201     VkSamplerYcbcrConversion                    ycbcrConversion,
5202     const VkAllocationCallbacks*                pAllocator);
5203 
5204 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(
5205     VkDevice                                    device,
5206     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
5207     const VkAllocationCallbacks*                pAllocator,
5208     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
5209 
5210 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(
5211     VkDevice                                    device,
5212     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5213     const VkAllocationCallbacks*                pAllocator);
5214 
5215 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(
5216     VkDevice                                    device,
5217     VkDescriptorSet                             descriptorSet,
5218     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5219     const void*                                 pData);
5220 
5221 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(
5222     VkPhysicalDevice                            physicalDevice,
5223     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
5224     VkExternalBufferProperties*                 pExternalBufferProperties);
5225 
5226 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(
5227     VkPhysicalDevice                            physicalDevice,
5228     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
5229     VkExternalFenceProperties*                  pExternalFenceProperties);
5230 
5231 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(
5232     VkPhysicalDevice                            physicalDevice,
5233     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
5234     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
5235 
5236 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(
5237     VkDevice                                    device,
5238     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
5239     VkDescriptorSetLayoutSupport*               pSupport);
5240 #endif
5241 
5242 
5243 #define VK_VERSION_1_2 1
5244 // Vulkan 1.2 version number
5245 #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0
5246 
5247 #define VK_MAX_DRIVER_NAME_SIZE           256U
5248 #define VK_MAX_DRIVER_INFO_SIZE           256U
5249 
5250 typedef enum VkDriverId {
5251     VK_DRIVER_ID_AMD_PROPRIETARY = 1,
5252     VK_DRIVER_ID_AMD_OPEN_SOURCE = 2,
5253     VK_DRIVER_ID_MESA_RADV = 3,
5254     VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4,
5255     VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5,
5256     VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6,
5257     VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7,
5258     VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8,
5259     VK_DRIVER_ID_ARM_PROPRIETARY = 9,
5260     VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10,
5261     VK_DRIVER_ID_GGP_PROPRIETARY = 11,
5262     VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12,
5263     VK_DRIVER_ID_MESA_LLVMPIPE = 13,
5264     VK_DRIVER_ID_MOLTENVK = 14,
5265     VK_DRIVER_ID_COREAVI_PROPRIETARY = 15,
5266     VK_DRIVER_ID_JUICE_PROPRIETARY = 16,
5267     VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
5268     VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
5269     VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
5270     VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY,
5271     VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS,
5272     VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA,
5273     VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY,
5274     VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
5275     VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY,
5276     VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER,
5277     VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY,
5278     VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY,
5279     VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF
5280 } VkDriverId;
5281 
5282 typedef enum VkShaderFloatControlsIndependence {
5283     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,
5284     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,
5285     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,
5286     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY,
5287     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
5288     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE,
5289     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF
5290 } VkShaderFloatControlsIndependence;
5291 
5292 typedef enum VkSamplerReductionMode {
5293     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0,
5294     VK_SAMPLER_REDUCTION_MODE_MIN = 1,
5295     VK_SAMPLER_REDUCTION_MODE_MAX = 2,
5296     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,
5297     VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN,
5298     VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX,
5299     VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF
5300 } VkSamplerReductionMode;
5301 
5302 typedef enum VkSemaphoreType {
5303     VK_SEMAPHORE_TYPE_BINARY = 0,
5304     VK_SEMAPHORE_TYPE_TIMELINE = 1,
5305     VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY,
5306     VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE,
5307     VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF
5308 } VkSemaphoreType;
5309 
5310 typedef enum VkResolveModeFlagBits {
5311     VK_RESOLVE_MODE_NONE = 0,
5312     VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001,
5313     VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002,
5314     VK_RESOLVE_MODE_MIN_BIT = 0x00000004,
5315     VK_RESOLVE_MODE_MAX_BIT = 0x00000008,
5316     VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE,
5317     VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
5318     VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT,
5319     VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT,
5320     VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT,
5321     VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
5322 } VkResolveModeFlagBits;
5323 typedef VkFlags VkResolveModeFlags;
5324 
5325 typedef enum VkDescriptorBindingFlagBits {
5326     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001,
5327     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002,
5328     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004,
5329     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008,
5330     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
5331     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
5332     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
5333     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT,
5334     VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
5335 } VkDescriptorBindingFlagBits;
5336 typedef VkFlags VkDescriptorBindingFlags;
5337 
5338 typedef enum VkSemaphoreWaitFlagBits {
5339     VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001,
5340     VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT,
5341     VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
5342 } VkSemaphoreWaitFlagBits;
5343 typedef VkFlags VkSemaphoreWaitFlags;
5344 typedef struct VkPhysicalDeviceVulkan11Features {
5345     VkStructureType    sType;
5346     void*              pNext;
5347     VkBool32           storageBuffer16BitAccess;
5348     VkBool32           uniformAndStorageBuffer16BitAccess;
5349     VkBool32           storagePushConstant16;
5350     VkBool32           storageInputOutput16;
5351     VkBool32           multiview;
5352     VkBool32           multiviewGeometryShader;
5353     VkBool32           multiviewTessellationShader;
5354     VkBool32           variablePointersStorageBuffer;
5355     VkBool32           variablePointers;
5356     VkBool32           protectedMemory;
5357     VkBool32           samplerYcbcrConversion;
5358     VkBool32           shaderDrawParameters;
5359 } VkPhysicalDeviceVulkan11Features;
5360 
5361 typedef struct VkPhysicalDeviceVulkan11Properties {
5362     VkStructureType            sType;
5363     void*                      pNext;
5364     uint8_t                    deviceUUID[VK_UUID_SIZE];
5365     uint8_t                    driverUUID[VK_UUID_SIZE];
5366     uint8_t                    deviceLUID[VK_LUID_SIZE];
5367     uint32_t                   deviceNodeMask;
5368     VkBool32                   deviceLUIDValid;
5369     uint32_t                   subgroupSize;
5370     VkShaderStageFlags         subgroupSupportedStages;
5371     VkSubgroupFeatureFlags     subgroupSupportedOperations;
5372     VkBool32                   subgroupQuadOperationsInAllStages;
5373     VkPointClippingBehavior    pointClippingBehavior;
5374     uint32_t                   maxMultiviewViewCount;
5375     uint32_t                   maxMultiviewInstanceIndex;
5376     VkBool32                   protectedNoFault;
5377     uint32_t                   maxPerSetDescriptors;
5378     VkDeviceSize               maxMemoryAllocationSize;
5379 } VkPhysicalDeviceVulkan11Properties;
5380 
5381 typedef struct VkPhysicalDeviceVulkan12Features {
5382     VkStructureType    sType;
5383     void*              pNext;
5384     VkBool32           samplerMirrorClampToEdge;
5385     VkBool32           drawIndirectCount;
5386     VkBool32           storageBuffer8BitAccess;
5387     VkBool32           uniformAndStorageBuffer8BitAccess;
5388     VkBool32           storagePushConstant8;
5389     VkBool32           shaderBufferInt64Atomics;
5390     VkBool32           shaderSharedInt64Atomics;
5391     VkBool32           shaderFloat16;
5392     VkBool32           shaderInt8;
5393     VkBool32           descriptorIndexing;
5394     VkBool32           shaderInputAttachmentArrayDynamicIndexing;
5395     VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
5396     VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
5397     VkBool32           shaderUniformBufferArrayNonUniformIndexing;
5398     VkBool32           shaderSampledImageArrayNonUniformIndexing;
5399     VkBool32           shaderStorageBufferArrayNonUniformIndexing;
5400     VkBool32           shaderStorageImageArrayNonUniformIndexing;
5401     VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
5402     VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
5403     VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
5404     VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
5405     VkBool32           descriptorBindingSampledImageUpdateAfterBind;
5406     VkBool32           descriptorBindingStorageImageUpdateAfterBind;
5407     VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
5408     VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
5409     VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
5410     VkBool32           descriptorBindingUpdateUnusedWhilePending;
5411     VkBool32           descriptorBindingPartiallyBound;
5412     VkBool32           descriptorBindingVariableDescriptorCount;
5413     VkBool32           runtimeDescriptorArray;
5414     VkBool32           samplerFilterMinmax;
5415     VkBool32           scalarBlockLayout;
5416     VkBool32           imagelessFramebuffer;
5417     VkBool32           uniformBufferStandardLayout;
5418     VkBool32           shaderSubgroupExtendedTypes;
5419     VkBool32           separateDepthStencilLayouts;
5420     VkBool32           hostQueryReset;
5421     VkBool32           timelineSemaphore;
5422     VkBool32           bufferDeviceAddress;
5423     VkBool32           bufferDeviceAddressCaptureReplay;
5424     VkBool32           bufferDeviceAddressMultiDevice;
5425     VkBool32           vulkanMemoryModel;
5426     VkBool32           vulkanMemoryModelDeviceScope;
5427     VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
5428     VkBool32           shaderOutputViewportIndex;
5429     VkBool32           shaderOutputLayer;
5430     VkBool32           subgroupBroadcastDynamicId;
5431 } VkPhysicalDeviceVulkan12Features;
5432 
5433 typedef struct VkConformanceVersion {
5434     uint8_t    major;
5435     uint8_t    minor;
5436     uint8_t    subminor;
5437     uint8_t    patch;
5438 } VkConformanceVersion;
5439 
5440 typedef struct VkPhysicalDeviceVulkan12Properties {
5441     VkStructureType                      sType;
5442     void*                                pNext;
5443     VkDriverId                           driverID;
5444     char                                 driverName[VK_MAX_DRIVER_NAME_SIZE];
5445     char                                 driverInfo[VK_MAX_DRIVER_INFO_SIZE];
5446     VkConformanceVersion                 conformanceVersion;
5447     VkShaderFloatControlsIndependence    denormBehaviorIndependence;
5448     VkShaderFloatControlsIndependence    roundingModeIndependence;
5449     VkBool32                             shaderSignedZeroInfNanPreserveFloat16;
5450     VkBool32                             shaderSignedZeroInfNanPreserveFloat32;
5451     VkBool32                             shaderSignedZeroInfNanPreserveFloat64;
5452     VkBool32                             shaderDenormPreserveFloat16;
5453     VkBool32                             shaderDenormPreserveFloat32;
5454     VkBool32                             shaderDenormPreserveFloat64;
5455     VkBool32                             shaderDenormFlushToZeroFloat16;
5456     VkBool32                             shaderDenormFlushToZeroFloat32;
5457     VkBool32                             shaderDenormFlushToZeroFloat64;
5458     VkBool32                             shaderRoundingModeRTEFloat16;
5459     VkBool32                             shaderRoundingModeRTEFloat32;
5460     VkBool32                             shaderRoundingModeRTEFloat64;
5461     VkBool32                             shaderRoundingModeRTZFloat16;
5462     VkBool32                             shaderRoundingModeRTZFloat32;
5463     VkBool32                             shaderRoundingModeRTZFloat64;
5464     uint32_t                             maxUpdateAfterBindDescriptorsInAllPools;
5465     VkBool32                             shaderUniformBufferArrayNonUniformIndexingNative;
5466     VkBool32                             shaderSampledImageArrayNonUniformIndexingNative;
5467     VkBool32                             shaderStorageBufferArrayNonUniformIndexingNative;
5468     VkBool32                             shaderStorageImageArrayNonUniformIndexingNative;
5469     VkBool32                             shaderInputAttachmentArrayNonUniformIndexingNative;
5470     VkBool32                             robustBufferAccessUpdateAfterBind;
5471     VkBool32                             quadDivergentImplicitLod;
5472     uint32_t                             maxPerStageDescriptorUpdateAfterBindSamplers;
5473     uint32_t                             maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5474     uint32_t                             maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5475     uint32_t                             maxPerStageDescriptorUpdateAfterBindSampledImages;
5476     uint32_t                             maxPerStageDescriptorUpdateAfterBindStorageImages;
5477     uint32_t                             maxPerStageDescriptorUpdateAfterBindInputAttachments;
5478     uint32_t                             maxPerStageUpdateAfterBindResources;
5479     uint32_t                             maxDescriptorSetUpdateAfterBindSamplers;
5480     uint32_t                             maxDescriptorSetUpdateAfterBindUniformBuffers;
5481     uint32_t                             maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5482     uint32_t                             maxDescriptorSetUpdateAfterBindStorageBuffers;
5483     uint32_t                             maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5484     uint32_t                             maxDescriptorSetUpdateAfterBindSampledImages;
5485     uint32_t                             maxDescriptorSetUpdateAfterBindStorageImages;
5486     uint32_t                             maxDescriptorSetUpdateAfterBindInputAttachments;
5487     VkResolveModeFlags                   supportedDepthResolveModes;
5488     VkResolveModeFlags                   supportedStencilResolveModes;
5489     VkBool32                             independentResolveNone;
5490     VkBool32                             independentResolve;
5491     VkBool32                             filterMinmaxSingleComponentFormats;
5492     VkBool32                             filterMinmaxImageComponentMapping;
5493     uint64_t                             maxTimelineSemaphoreValueDifference;
5494     VkSampleCountFlags                   framebufferIntegerColorSampleCounts;
5495 } VkPhysicalDeviceVulkan12Properties;
5496 
5497 typedef struct VkImageFormatListCreateInfo {
5498     VkStructureType    sType;
5499     const void*        pNext;
5500     uint32_t           viewFormatCount;
5501     const VkFormat*    pViewFormats;
5502 } VkImageFormatListCreateInfo;
5503 
5504 typedef struct VkAttachmentDescription2 {
5505     VkStructureType                 sType;
5506     const void*                     pNext;
5507     VkAttachmentDescriptionFlags    flags;
5508     VkFormat                        format;
5509     VkSampleCountFlagBits           samples;
5510     VkAttachmentLoadOp              loadOp;
5511     VkAttachmentStoreOp             storeOp;
5512     VkAttachmentLoadOp              stencilLoadOp;
5513     VkAttachmentStoreOp             stencilStoreOp;
5514     VkImageLayout                   initialLayout;
5515     VkImageLayout                   finalLayout;
5516 } VkAttachmentDescription2;
5517 
5518 typedef struct VkAttachmentReference2 {
5519     VkStructureType       sType;
5520     const void*           pNext;
5521     uint32_t              attachment;
5522     VkImageLayout         layout;
5523     VkImageAspectFlags    aspectMask;
5524 } VkAttachmentReference2;
5525 
5526 typedef struct VkSubpassDescription2 {
5527     VkStructureType                  sType;
5528     const void*                      pNext;
5529     VkSubpassDescriptionFlags        flags;
5530     VkPipelineBindPoint              pipelineBindPoint;
5531     uint32_t                         viewMask;
5532     uint32_t                         inputAttachmentCount;
5533     const VkAttachmentReference2*    pInputAttachments;
5534     uint32_t                         colorAttachmentCount;
5535     const VkAttachmentReference2*    pColorAttachments;
5536     const VkAttachmentReference2*    pResolveAttachments;
5537     const VkAttachmentReference2*    pDepthStencilAttachment;
5538     uint32_t                         preserveAttachmentCount;
5539     const uint32_t*                  pPreserveAttachments;
5540 } VkSubpassDescription2;
5541 
5542 typedef struct VkSubpassDependency2 {
5543     VkStructureType         sType;
5544     const void*             pNext;
5545     uint32_t                srcSubpass;
5546     uint32_t                dstSubpass;
5547     VkPipelineStageFlags    srcStageMask;
5548     VkPipelineStageFlags    dstStageMask;
5549     VkAccessFlags           srcAccessMask;
5550     VkAccessFlags           dstAccessMask;
5551     VkDependencyFlags       dependencyFlags;
5552     int32_t                 viewOffset;
5553 } VkSubpassDependency2;
5554 
5555 typedef struct VkRenderPassCreateInfo2 {
5556     VkStructureType                    sType;
5557     const void*                        pNext;
5558     VkRenderPassCreateFlags            flags;
5559     uint32_t                           attachmentCount;
5560     const VkAttachmentDescription2*    pAttachments;
5561     uint32_t                           subpassCount;
5562     const VkSubpassDescription2*       pSubpasses;
5563     uint32_t                           dependencyCount;
5564     const VkSubpassDependency2*        pDependencies;
5565     uint32_t                           correlatedViewMaskCount;
5566     const uint32_t*                    pCorrelatedViewMasks;
5567 } VkRenderPassCreateInfo2;
5568 
5569 typedef struct VkSubpassBeginInfo {
5570     VkStructureType      sType;
5571     const void*          pNext;
5572     VkSubpassContents    contents;
5573 } VkSubpassBeginInfo;
5574 
5575 typedef struct VkSubpassEndInfo {
5576     VkStructureType    sType;
5577     const void*        pNext;
5578 } VkSubpassEndInfo;
5579 
5580 typedef struct VkPhysicalDevice8BitStorageFeatures {
5581     VkStructureType    sType;
5582     void*              pNext;
5583     VkBool32           storageBuffer8BitAccess;
5584     VkBool32           uniformAndStorageBuffer8BitAccess;
5585     VkBool32           storagePushConstant8;
5586 } VkPhysicalDevice8BitStorageFeatures;
5587 
5588 typedef struct VkPhysicalDeviceDriverProperties {
5589     VkStructureType         sType;
5590     void*                   pNext;
5591     VkDriverId              driverID;
5592     char                    driverName[VK_MAX_DRIVER_NAME_SIZE];
5593     char                    driverInfo[VK_MAX_DRIVER_INFO_SIZE];
5594     VkConformanceVersion    conformanceVersion;
5595 } VkPhysicalDeviceDriverProperties;
5596 
5597 typedef struct VkPhysicalDeviceShaderAtomicInt64Features {
5598     VkStructureType    sType;
5599     void*              pNext;
5600     VkBool32           shaderBufferInt64Atomics;
5601     VkBool32           shaderSharedInt64Atomics;
5602 } VkPhysicalDeviceShaderAtomicInt64Features;
5603 
5604 typedef struct VkPhysicalDeviceShaderFloat16Int8Features {
5605     VkStructureType    sType;
5606     void*              pNext;
5607     VkBool32           shaderFloat16;
5608     VkBool32           shaderInt8;
5609 } VkPhysicalDeviceShaderFloat16Int8Features;
5610 
5611 typedef struct VkPhysicalDeviceFloatControlsProperties {
5612     VkStructureType                      sType;
5613     void*                                pNext;
5614     VkShaderFloatControlsIndependence    denormBehaviorIndependence;
5615     VkShaderFloatControlsIndependence    roundingModeIndependence;
5616     VkBool32                             shaderSignedZeroInfNanPreserveFloat16;
5617     VkBool32                             shaderSignedZeroInfNanPreserveFloat32;
5618     VkBool32                             shaderSignedZeroInfNanPreserveFloat64;
5619     VkBool32                             shaderDenormPreserveFloat16;
5620     VkBool32                             shaderDenormPreserveFloat32;
5621     VkBool32                             shaderDenormPreserveFloat64;
5622     VkBool32                             shaderDenormFlushToZeroFloat16;
5623     VkBool32                             shaderDenormFlushToZeroFloat32;
5624     VkBool32                             shaderDenormFlushToZeroFloat64;
5625     VkBool32                             shaderRoundingModeRTEFloat16;
5626     VkBool32                             shaderRoundingModeRTEFloat32;
5627     VkBool32                             shaderRoundingModeRTEFloat64;
5628     VkBool32                             shaderRoundingModeRTZFloat16;
5629     VkBool32                             shaderRoundingModeRTZFloat32;
5630     VkBool32                             shaderRoundingModeRTZFloat64;
5631 } VkPhysicalDeviceFloatControlsProperties;
5632 
5633 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo {
5634     VkStructureType                    sType;
5635     const void*                        pNext;
5636     uint32_t                           bindingCount;
5637     const VkDescriptorBindingFlags*    pBindingFlags;
5638 } VkDescriptorSetLayoutBindingFlagsCreateInfo;
5639 
5640 typedef struct VkPhysicalDeviceDescriptorIndexingFeatures {
5641     VkStructureType    sType;
5642     void*              pNext;
5643     VkBool32           shaderInputAttachmentArrayDynamicIndexing;
5644     VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
5645     VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
5646     VkBool32           shaderUniformBufferArrayNonUniformIndexing;
5647     VkBool32           shaderSampledImageArrayNonUniformIndexing;
5648     VkBool32           shaderStorageBufferArrayNonUniformIndexing;
5649     VkBool32           shaderStorageImageArrayNonUniformIndexing;
5650     VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
5651     VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
5652     VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
5653     VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
5654     VkBool32           descriptorBindingSampledImageUpdateAfterBind;
5655     VkBool32           descriptorBindingStorageImageUpdateAfterBind;
5656     VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
5657     VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
5658     VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
5659     VkBool32           descriptorBindingUpdateUnusedWhilePending;
5660     VkBool32           descriptorBindingPartiallyBound;
5661     VkBool32           descriptorBindingVariableDescriptorCount;
5662     VkBool32           runtimeDescriptorArray;
5663 } VkPhysicalDeviceDescriptorIndexingFeatures;
5664 
5665 typedef struct VkPhysicalDeviceDescriptorIndexingProperties {
5666     VkStructureType    sType;
5667     void*              pNext;
5668     uint32_t           maxUpdateAfterBindDescriptorsInAllPools;
5669     VkBool32           shaderUniformBufferArrayNonUniformIndexingNative;
5670     VkBool32           shaderSampledImageArrayNonUniformIndexingNative;
5671     VkBool32           shaderStorageBufferArrayNonUniformIndexingNative;
5672     VkBool32           shaderStorageImageArrayNonUniformIndexingNative;
5673     VkBool32           shaderInputAttachmentArrayNonUniformIndexingNative;
5674     VkBool32           robustBufferAccessUpdateAfterBind;
5675     VkBool32           quadDivergentImplicitLod;
5676     uint32_t           maxPerStageDescriptorUpdateAfterBindSamplers;
5677     uint32_t           maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5678     uint32_t           maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5679     uint32_t           maxPerStageDescriptorUpdateAfterBindSampledImages;
5680     uint32_t           maxPerStageDescriptorUpdateAfterBindStorageImages;
5681     uint32_t           maxPerStageDescriptorUpdateAfterBindInputAttachments;
5682     uint32_t           maxPerStageUpdateAfterBindResources;
5683     uint32_t           maxDescriptorSetUpdateAfterBindSamplers;
5684     uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffers;
5685     uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5686     uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffers;
5687     uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5688     uint32_t           maxDescriptorSetUpdateAfterBindSampledImages;
5689     uint32_t           maxDescriptorSetUpdateAfterBindStorageImages;
5690     uint32_t           maxDescriptorSetUpdateAfterBindInputAttachments;
5691 } VkPhysicalDeviceDescriptorIndexingProperties;
5692 
5693 typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo {
5694     VkStructureType    sType;
5695     const void*        pNext;
5696     uint32_t           descriptorSetCount;
5697     const uint32_t*    pDescriptorCounts;
5698 } VkDescriptorSetVariableDescriptorCountAllocateInfo;
5699 
5700 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport {
5701     VkStructureType    sType;
5702     void*              pNext;
5703     uint32_t           maxVariableDescriptorCount;
5704 } VkDescriptorSetVariableDescriptorCountLayoutSupport;
5705 
5706 typedef struct VkSubpassDescriptionDepthStencilResolve {
5707     VkStructureType                  sType;
5708     const void*                      pNext;
5709     VkResolveModeFlagBits            depthResolveMode;
5710     VkResolveModeFlagBits            stencilResolveMode;
5711     const VkAttachmentReference2*    pDepthStencilResolveAttachment;
5712 } VkSubpassDescriptionDepthStencilResolve;
5713 
5714 typedef struct VkPhysicalDeviceDepthStencilResolveProperties {
5715     VkStructureType       sType;
5716     void*                 pNext;
5717     VkResolveModeFlags    supportedDepthResolveModes;
5718     VkResolveModeFlags    supportedStencilResolveModes;
5719     VkBool32              independentResolveNone;
5720     VkBool32              independentResolve;
5721 } VkPhysicalDeviceDepthStencilResolveProperties;
5722 
5723 typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures {
5724     VkStructureType    sType;
5725     void*              pNext;
5726     VkBool32           scalarBlockLayout;
5727 } VkPhysicalDeviceScalarBlockLayoutFeatures;
5728 
5729 typedef struct VkImageStencilUsageCreateInfo {
5730     VkStructureType      sType;
5731     const void*          pNext;
5732     VkImageUsageFlags    stencilUsage;
5733 } VkImageStencilUsageCreateInfo;
5734 
5735 typedef struct VkSamplerReductionModeCreateInfo {
5736     VkStructureType           sType;
5737     const void*               pNext;
5738     VkSamplerReductionMode    reductionMode;
5739 } VkSamplerReductionModeCreateInfo;
5740 
5741 typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
5742     VkStructureType    sType;
5743     void*              pNext;
5744     VkBool32           filterMinmaxSingleComponentFormats;
5745     VkBool32           filterMinmaxImageComponentMapping;
5746 } VkPhysicalDeviceSamplerFilterMinmaxProperties;
5747 
5748 typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures {
5749     VkStructureType    sType;
5750     void*              pNext;
5751     VkBool32           vulkanMemoryModel;
5752     VkBool32           vulkanMemoryModelDeviceScope;
5753     VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
5754 } VkPhysicalDeviceVulkanMemoryModelFeatures;
5755 
5756 typedef struct VkPhysicalDeviceImagelessFramebufferFeatures {
5757     VkStructureType    sType;
5758     void*              pNext;
5759     VkBool32           imagelessFramebuffer;
5760 } VkPhysicalDeviceImagelessFramebufferFeatures;
5761 
5762 typedef struct VkFramebufferAttachmentImageInfo {
5763     VkStructureType       sType;
5764     const void*           pNext;
5765     VkImageCreateFlags    flags;
5766     VkImageUsageFlags     usage;
5767     uint32_t              width;
5768     uint32_t              height;
5769     uint32_t              layerCount;
5770     uint32_t              viewFormatCount;
5771     const VkFormat*       pViewFormats;
5772 } VkFramebufferAttachmentImageInfo;
5773 
5774 typedef struct VkFramebufferAttachmentsCreateInfo {
5775     VkStructureType                            sType;
5776     const void*                                pNext;
5777     uint32_t                                   attachmentImageInfoCount;
5778     const VkFramebufferAttachmentImageInfo*    pAttachmentImageInfos;
5779 } VkFramebufferAttachmentsCreateInfo;
5780 
5781 typedef struct VkRenderPassAttachmentBeginInfo {
5782     VkStructureType       sType;
5783     const void*           pNext;
5784     uint32_t              attachmentCount;
5785     const VkImageView*    pAttachments;
5786 } VkRenderPassAttachmentBeginInfo;
5787 
5788 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
5789     VkStructureType    sType;
5790     void*              pNext;
5791     VkBool32           uniformBufferStandardLayout;
5792 } VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
5793 
5794 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
5795     VkStructureType    sType;
5796     void*              pNext;
5797     VkBool32           shaderSubgroupExtendedTypes;
5798 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
5799 
5800 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
5801     VkStructureType    sType;
5802     void*              pNext;
5803     VkBool32           separateDepthStencilLayouts;
5804 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
5805 
5806 typedef struct VkAttachmentReferenceStencilLayout {
5807     VkStructureType    sType;
5808     void*              pNext;
5809     VkImageLayout      stencilLayout;
5810 } VkAttachmentReferenceStencilLayout;
5811 
5812 typedef struct VkAttachmentDescriptionStencilLayout {
5813     VkStructureType    sType;
5814     void*              pNext;
5815     VkImageLayout      stencilInitialLayout;
5816     VkImageLayout      stencilFinalLayout;
5817 } VkAttachmentDescriptionStencilLayout;
5818 
5819 typedef struct VkPhysicalDeviceHostQueryResetFeatures {
5820     VkStructureType    sType;
5821     void*              pNext;
5822     VkBool32           hostQueryReset;
5823 } VkPhysicalDeviceHostQueryResetFeatures;
5824 
5825 typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures {
5826     VkStructureType    sType;
5827     void*              pNext;
5828     VkBool32           timelineSemaphore;
5829 } VkPhysicalDeviceTimelineSemaphoreFeatures;
5830 
5831 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties {
5832     VkStructureType    sType;
5833     void*              pNext;
5834     uint64_t           maxTimelineSemaphoreValueDifference;
5835 } VkPhysicalDeviceTimelineSemaphoreProperties;
5836 
5837 typedef struct VkSemaphoreTypeCreateInfo {
5838     VkStructureType    sType;
5839     const void*        pNext;
5840     VkSemaphoreType    semaphoreType;
5841     uint64_t           initialValue;
5842 } VkSemaphoreTypeCreateInfo;
5843 
5844 typedef struct VkTimelineSemaphoreSubmitInfo {
5845     VkStructureType    sType;
5846     const void*        pNext;
5847     uint32_t           waitSemaphoreValueCount;
5848     const uint64_t*    pWaitSemaphoreValues;
5849     uint32_t           signalSemaphoreValueCount;
5850     const uint64_t*    pSignalSemaphoreValues;
5851 } VkTimelineSemaphoreSubmitInfo;
5852 
5853 typedef struct VkSemaphoreWaitInfo {
5854     VkStructureType         sType;
5855     const void*             pNext;
5856     VkSemaphoreWaitFlags    flags;
5857     uint32_t                semaphoreCount;
5858     const VkSemaphore*      pSemaphores;
5859     const uint64_t*         pValues;
5860 } VkSemaphoreWaitInfo;
5861 
5862 typedef struct VkSemaphoreSignalInfo {
5863     VkStructureType    sType;
5864     const void*        pNext;
5865     VkSemaphore        semaphore;
5866     uint64_t           value;
5867 } VkSemaphoreSignalInfo;
5868 
5869 typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures {
5870     VkStructureType    sType;
5871     void*              pNext;
5872     VkBool32           bufferDeviceAddress;
5873     VkBool32           bufferDeviceAddressCaptureReplay;
5874     VkBool32           bufferDeviceAddressMultiDevice;
5875 } VkPhysicalDeviceBufferDeviceAddressFeatures;
5876 
5877 typedef struct VkBufferDeviceAddressInfo {
5878     VkStructureType    sType;
5879     const void*        pNext;
5880     VkBuffer           buffer;
5881 } VkBufferDeviceAddressInfo;
5882 
5883 typedef struct VkBufferOpaqueCaptureAddressCreateInfo {
5884     VkStructureType    sType;
5885     const void*        pNext;
5886     uint64_t           opaqueCaptureAddress;
5887 } VkBufferOpaqueCaptureAddressCreateInfo;
5888 
5889 typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo {
5890     VkStructureType    sType;
5891     const void*        pNext;
5892     uint64_t           opaqueCaptureAddress;
5893 } VkMemoryOpaqueCaptureAddressAllocateInfo;
5894 
5895 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo {
5896     VkStructureType    sType;
5897     const void*        pNext;
5898     VkDeviceMemory     memory;
5899 } VkDeviceMemoryOpaqueCaptureAddressInfo;
5900 
5901 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
5902 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
5903 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
5904 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfo*      pSubpassBeginInfo);
5905 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo*      pSubpassBeginInfo, const VkSubpassEndInfo*        pSubpassEndInfo);
5906 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo*        pSubpassEndInfo);
5907 typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
5908 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
5909 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
5910 typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
5911 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
5912 typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
5913 typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
5914 
5915 #ifndef VK_NO_PROTOTYPES
5916 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(
5917     VkCommandBuffer                             commandBuffer,
5918     VkBuffer                                    buffer,
5919     VkDeviceSize                                offset,
5920     VkBuffer                                    countBuffer,
5921     VkDeviceSize                                countBufferOffset,
5922     uint32_t                                    maxDrawCount,
5923     uint32_t                                    stride);
5924 
5925 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(
5926     VkCommandBuffer                             commandBuffer,
5927     VkBuffer                                    buffer,
5928     VkDeviceSize                                offset,
5929     VkBuffer                                    countBuffer,
5930     VkDeviceSize                                countBufferOffset,
5931     uint32_t                                    maxDrawCount,
5932     uint32_t                                    stride);
5933 
5934 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(
5935     VkDevice                                    device,
5936     const VkRenderPassCreateInfo2*              pCreateInfo,
5937     const VkAllocationCallbacks*                pAllocator,
5938     VkRenderPass*                               pRenderPass);
5939 
5940 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(
5941     VkCommandBuffer                             commandBuffer,
5942     const VkRenderPassBeginInfo*                pRenderPassBegin,
5943     const VkSubpassBeginInfo*                   pSubpassBeginInfo);
5944 
5945 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(
5946     VkCommandBuffer                             commandBuffer,
5947     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
5948     const VkSubpassEndInfo*                     pSubpassEndInfo);
5949 
5950 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(
5951     VkCommandBuffer                             commandBuffer,
5952     const VkSubpassEndInfo*                     pSubpassEndInfo);
5953 
5954 VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(
5955     VkDevice                                    device,
5956     VkQueryPool                                 queryPool,
5957     uint32_t                                    firstQuery,
5958     uint32_t                                    queryCount);
5959 
5960 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(
5961     VkDevice                                    device,
5962     VkSemaphore                                 semaphore,
5963     uint64_t*                                   pValue);
5964 
5965 VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(
5966     VkDevice                                    device,
5967     const VkSemaphoreWaitInfo*                  pWaitInfo,
5968     uint64_t                                    timeout);
5969 
5970 VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(
5971     VkDevice                                    device,
5972     const VkSemaphoreSignalInfo*                pSignalInfo);
5973 
5974 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(
5975     VkDevice                                    device,
5976     const VkBufferDeviceAddressInfo*            pInfo);
5977 
5978 VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(
5979     VkDevice                                    device,
5980     const VkBufferDeviceAddressInfo*            pInfo);
5981 
5982 VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(
5983     VkDevice                                    device,
5984     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
5985 #endif
5986 
5987 
5988 #define VK_KHR_surface 1
5989 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
5990 #define VK_KHR_SURFACE_SPEC_VERSION       25
5991 #define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
5992 
5993 typedef enum VkPresentModeKHR {
5994     VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
5995     VK_PRESENT_MODE_MAILBOX_KHR = 1,
5996     VK_PRESENT_MODE_FIFO_KHR = 2,
5997     VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
5998     VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
5999     VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
6000     VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
6001 } VkPresentModeKHR;
6002 
6003 typedef enum VkColorSpaceKHR {
6004     VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
6005     VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
6006     VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
6007     VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003,
6008     VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
6009     VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
6010     VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
6011     VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
6012     VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
6013     VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
6014     VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
6015     VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
6016     VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
6017     VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
6018     VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
6019     VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000,
6020     VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
6021     VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
6022     VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
6023 } VkColorSpaceKHR;
6024 
6025 typedef enum VkSurfaceTransformFlagBitsKHR {
6026     VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
6027     VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
6028     VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
6029     VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
6030     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
6031     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
6032     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
6033     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
6034     VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
6035     VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6036 } VkSurfaceTransformFlagBitsKHR;
6037 
6038 typedef enum VkCompositeAlphaFlagBitsKHR {
6039     VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
6040     VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
6041     VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
6042     VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
6043     VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6044 } VkCompositeAlphaFlagBitsKHR;
6045 typedef VkFlags VkCompositeAlphaFlagsKHR;
6046 typedef VkFlags VkSurfaceTransformFlagsKHR;
6047 typedef struct VkSurfaceCapabilitiesKHR {
6048     uint32_t                         minImageCount;
6049     uint32_t                         maxImageCount;
6050     VkExtent2D                       currentExtent;
6051     VkExtent2D                       minImageExtent;
6052     VkExtent2D                       maxImageExtent;
6053     uint32_t                         maxImageArrayLayers;
6054     VkSurfaceTransformFlagsKHR       supportedTransforms;
6055     VkSurfaceTransformFlagBitsKHR    currentTransform;
6056     VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
6057     VkImageUsageFlags                supportedUsageFlags;
6058 } VkSurfaceCapabilitiesKHR;
6059 
6060 typedef struct VkSurfaceFormatKHR {
6061     VkFormat           format;
6062     VkColorSpaceKHR    colorSpace;
6063 } VkSurfaceFormatKHR;
6064 
6065 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
6066 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
6067 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
6068 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
6069 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
6070 
6071 #ifndef VK_NO_PROTOTYPES
6072 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
6073     VkInstance                                  instance,
6074     VkSurfaceKHR                                surface,
6075     const VkAllocationCallbacks*                pAllocator);
6076 
6077 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
6078     VkPhysicalDevice                            physicalDevice,
6079     uint32_t                                    queueFamilyIndex,
6080     VkSurfaceKHR                                surface,
6081     VkBool32*                                   pSupported);
6082 
6083 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
6084     VkPhysicalDevice                            physicalDevice,
6085     VkSurfaceKHR                                surface,
6086     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
6087 
6088 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
6089     VkPhysicalDevice                            physicalDevice,
6090     VkSurfaceKHR                                surface,
6091     uint32_t*                                   pSurfaceFormatCount,
6092     VkSurfaceFormatKHR*                         pSurfaceFormats);
6093 
6094 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
6095     VkPhysicalDevice                            physicalDevice,
6096     VkSurfaceKHR                                surface,
6097     uint32_t*                                   pPresentModeCount,
6098     VkPresentModeKHR*                           pPresentModes);
6099 #endif
6100 
6101 
6102 #define VK_KHR_swapchain 1
6103 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
6104 #define VK_KHR_SWAPCHAIN_SPEC_VERSION     70
6105 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
6106 
6107 typedef enum VkSwapchainCreateFlagBitsKHR {
6108     VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,
6109     VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002,
6110     VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004,
6111     VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6112 } VkSwapchainCreateFlagBitsKHR;
6113 typedef VkFlags VkSwapchainCreateFlagsKHR;
6114 
6115 typedef enum VkDeviceGroupPresentModeFlagBitsKHR {
6116     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001,
6117     VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002,
6118     VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004,
6119     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,
6120     VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6121 } VkDeviceGroupPresentModeFlagBitsKHR;
6122 typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;
6123 typedef struct VkSwapchainCreateInfoKHR {
6124     VkStructureType                  sType;
6125     const void*                      pNext;
6126     VkSwapchainCreateFlagsKHR        flags;
6127     VkSurfaceKHR                     surface;
6128     uint32_t                         minImageCount;
6129     VkFormat                         imageFormat;
6130     VkColorSpaceKHR                  imageColorSpace;
6131     VkExtent2D                       imageExtent;
6132     uint32_t                         imageArrayLayers;
6133     VkImageUsageFlags                imageUsage;
6134     VkSharingMode                    imageSharingMode;
6135     uint32_t                         queueFamilyIndexCount;
6136     const uint32_t*                  pQueueFamilyIndices;
6137     VkSurfaceTransformFlagBitsKHR    preTransform;
6138     VkCompositeAlphaFlagBitsKHR      compositeAlpha;
6139     VkPresentModeKHR                 presentMode;
6140     VkBool32                         clipped;
6141     VkSwapchainKHR                   oldSwapchain;
6142 } VkSwapchainCreateInfoKHR;
6143 
6144 typedef struct VkPresentInfoKHR {
6145     VkStructureType          sType;
6146     const void*              pNext;
6147     uint32_t                 waitSemaphoreCount;
6148     const VkSemaphore*       pWaitSemaphores;
6149     uint32_t                 swapchainCount;
6150     const VkSwapchainKHR*    pSwapchains;
6151     const uint32_t*          pImageIndices;
6152     VkResult*                pResults;
6153 } VkPresentInfoKHR;
6154 
6155 typedef struct VkImageSwapchainCreateInfoKHR {
6156     VkStructureType    sType;
6157     const void*        pNext;
6158     VkSwapchainKHR     swapchain;
6159 } VkImageSwapchainCreateInfoKHR;
6160 
6161 typedef struct VkBindImageMemorySwapchainInfoKHR {
6162     VkStructureType    sType;
6163     const void*        pNext;
6164     VkSwapchainKHR     swapchain;
6165     uint32_t           imageIndex;
6166 } VkBindImageMemorySwapchainInfoKHR;
6167 
6168 typedef struct VkAcquireNextImageInfoKHR {
6169     VkStructureType    sType;
6170     const void*        pNext;
6171     VkSwapchainKHR     swapchain;
6172     uint64_t           timeout;
6173     VkSemaphore        semaphore;
6174     VkFence            fence;
6175     uint32_t           deviceMask;
6176 } VkAcquireNextImageInfoKHR;
6177 
6178 typedef struct VkDeviceGroupPresentCapabilitiesKHR {
6179     VkStructureType                     sType;
6180     const void*                         pNext;
6181     uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE];
6182     VkDeviceGroupPresentModeFlagsKHR    modes;
6183 } VkDeviceGroupPresentCapabilitiesKHR;
6184 
6185 typedef struct VkDeviceGroupPresentInfoKHR {
6186     VkStructureType                        sType;
6187     const void*                            pNext;
6188     uint32_t                               swapchainCount;
6189     const uint32_t*                        pDeviceMasks;
6190     VkDeviceGroupPresentModeFlagBitsKHR    mode;
6191 } VkDeviceGroupPresentInfoKHR;
6192 
6193 typedef struct VkDeviceGroupSwapchainCreateInfoKHR {
6194     VkStructureType                     sType;
6195     const void*                         pNext;
6196     VkDeviceGroupPresentModeFlagsKHR    modes;
6197 } VkDeviceGroupSwapchainCreateInfoKHR;
6198 
6199 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
6200 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
6201 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
6202 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
6203 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
6204 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
6205 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
6206 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
6207 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
6208 
6209 #ifndef VK_NO_PROTOTYPES
6210 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
6211     VkDevice                                    device,
6212     const VkSwapchainCreateInfoKHR*             pCreateInfo,
6213     const VkAllocationCallbacks*                pAllocator,
6214     VkSwapchainKHR*                             pSwapchain);
6215 
6216 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
6217     VkDevice                                    device,
6218     VkSwapchainKHR                              swapchain,
6219     const VkAllocationCallbacks*                pAllocator);
6220 
6221 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
6222     VkDevice                                    device,
6223     VkSwapchainKHR                              swapchain,
6224     uint32_t*                                   pSwapchainImageCount,
6225     VkImage*                                    pSwapchainImages);
6226 
6227 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
6228     VkDevice                                    device,
6229     VkSwapchainKHR                              swapchain,
6230     uint64_t                                    timeout,
6231     VkSemaphore                                 semaphore,
6232     VkFence                                     fence,
6233     uint32_t*                                   pImageIndex);
6234 
6235 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
6236     VkQueue                                     queue,
6237     const VkPresentInfoKHR*                     pPresentInfo);
6238 
6239 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(
6240     VkDevice                                    device,
6241     VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
6242 
6243 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(
6244     VkDevice                                    device,
6245     VkSurfaceKHR                                surface,
6246     VkDeviceGroupPresentModeFlagsKHR*           pModes);
6247 
6248 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(
6249     VkPhysicalDevice                            physicalDevice,
6250     VkSurfaceKHR                                surface,
6251     uint32_t*                                   pRectCount,
6252     VkRect2D*                                   pRects);
6253 
6254 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(
6255     VkDevice                                    device,
6256     const VkAcquireNextImageInfoKHR*            pAcquireInfo,
6257     uint32_t*                                   pImageIndex);
6258 #endif
6259 
6260 
6261 #define VK_KHR_display 1
6262 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
6263 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
6264 #define VK_KHR_DISPLAY_SPEC_VERSION       23
6265 #define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
6266 typedef VkFlags VkDisplayModeCreateFlagsKHR;
6267 
6268 typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
6269     VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
6270     VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
6271     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
6272     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
6273     VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6274 } VkDisplayPlaneAlphaFlagBitsKHR;
6275 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
6276 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
6277 typedef struct VkDisplayModeParametersKHR {
6278     VkExtent2D    visibleRegion;
6279     uint32_t      refreshRate;
6280 } VkDisplayModeParametersKHR;
6281 
6282 typedef struct VkDisplayModeCreateInfoKHR {
6283     VkStructureType                sType;
6284     const void*                    pNext;
6285     VkDisplayModeCreateFlagsKHR    flags;
6286     VkDisplayModeParametersKHR     parameters;
6287 } VkDisplayModeCreateInfoKHR;
6288 
6289 typedef struct VkDisplayModePropertiesKHR {
6290     VkDisplayModeKHR              displayMode;
6291     VkDisplayModeParametersKHR    parameters;
6292 } VkDisplayModePropertiesKHR;
6293 
6294 typedef struct VkDisplayPlaneCapabilitiesKHR {
6295     VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
6296     VkOffset2D                     minSrcPosition;
6297     VkOffset2D                     maxSrcPosition;
6298     VkExtent2D                     minSrcExtent;
6299     VkExtent2D                     maxSrcExtent;
6300     VkOffset2D                     minDstPosition;
6301     VkOffset2D                     maxDstPosition;
6302     VkExtent2D                     minDstExtent;
6303     VkExtent2D                     maxDstExtent;
6304 } VkDisplayPlaneCapabilitiesKHR;
6305 
6306 typedef struct VkDisplayPlanePropertiesKHR {
6307     VkDisplayKHR    currentDisplay;
6308     uint32_t        currentStackIndex;
6309 } VkDisplayPlanePropertiesKHR;
6310 
6311 typedef struct VkDisplayPropertiesKHR {
6312     VkDisplayKHR                  display;
6313     const char*                   displayName;
6314     VkExtent2D                    physicalDimensions;
6315     VkExtent2D                    physicalResolution;
6316     VkSurfaceTransformFlagsKHR    supportedTransforms;
6317     VkBool32                      planeReorderPossible;
6318     VkBool32                      persistentContent;
6319 } VkDisplayPropertiesKHR;
6320 
6321 typedef struct VkDisplaySurfaceCreateInfoKHR {
6322     VkStructureType                   sType;
6323     const void*                       pNext;
6324     VkDisplaySurfaceCreateFlagsKHR    flags;
6325     VkDisplayModeKHR                  displayMode;
6326     uint32_t                          planeIndex;
6327     uint32_t                          planeStackIndex;
6328     VkSurfaceTransformFlagBitsKHR     transform;
6329     float                             globalAlpha;
6330     VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
6331     VkExtent2D                        imageExtent;
6332 } VkDisplaySurfaceCreateInfoKHR;
6333 
6334 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
6335 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
6336 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
6337 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
6338 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
6339 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
6340 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
6341 
6342 #ifndef VK_NO_PROTOTYPES
6343 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
6344     VkPhysicalDevice                            physicalDevice,
6345     uint32_t*                                   pPropertyCount,
6346     VkDisplayPropertiesKHR*                     pProperties);
6347 
6348 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
6349     VkPhysicalDevice                            physicalDevice,
6350     uint32_t*                                   pPropertyCount,
6351     VkDisplayPlanePropertiesKHR*                pProperties);
6352 
6353 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
6354     VkPhysicalDevice                            physicalDevice,
6355     uint32_t                                    planeIndex,
6356     uint32_t*                                   pDisplayCount,
6357     VkDisplayKHR*                               pDisplays);
6358 
6359 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
6360     VkPhysicalDevice                            physicalDevice,
6361     VkDisplayKHR                                display,
6362     uint32_t*                                   pPropertyCount,
6363     VkDisplayModePropertiesKHR*                 pProperties);
6364 
6365 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
6366     VkPhysicalDevice                            physicalDevice,
6367     VkDisplayKHR                                display,
6368     const VkDisplayModeCreateInfoKHR*           pCreateInfo,
6369     const VkAllocationCallbacks*                pAllocator,
6370     VkDisplayModeKHR*                           pMode);
6371 
6372 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
6373     VkPhysicalDevice                            physicalDevice,
6374     VkDisplayModeKHR                            mode,
6375     uint32_t                                    planeIndex,
6376     VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
6377 
6378 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
6379     VkInstance                                  instance,
6380     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
6381     const VkAllocationCallbacks*                pAllocator,
6382     VkSurfaceKHR*                               pSurface);
6383 #endif
6384 
6385 
6386 #define VK_KHR_display_swapchain 1
6387 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10
6388 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
6389 typedef struct VkDisplayPresentInfoKHR {
6390     VkStructureType    sType;
6391     const void*        pNext;
6392     VkRect2D           srcRect;
6393     VkRect2D           dstRect;
6394     VkBool32           persistent;
6395 } VkDisplayPresentInfoKHR;
6396 
6397 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
6398 
6399 #ifndef VK_NO_PROTOTYPES
6400 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
6401     VkDevice                                    device,
6402     uint32_t                                    swapchainCount,
6403     const VkSwapchainCreateInfoKHR*             pCreateInfos,
6404     const VkAllocationCallbacks*                pAllocator,
6405     VkSwapchainKHR*                             pSwapchains);
6406 #endif
6407 
6408 
6409 #define VK_KHR_sampler_mirror_clamp_to_edge 1
6410 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3
6411 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
6412 
6413 
6414 #define VK_KHR_multiview 1
6415 #define VK_KHR_MULTIVIEW_SPEC_VERSION     1
6416 #define VK_KHR_MULTIVIEW_EXTENSION_NAME   "VK_KHR_multiview"
6417 typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
6418 
6419 typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;
6420 
6421 typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;
6422 
6423 
6424 
6425 #define VK_KHR_get_physical_device_properties2 1
6426 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2
6427 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
6428 typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
6429 
6430 typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
6431 
6432 typedef VkFormatProperties2 VkFormatProperties2KHR;
6433 
6434 typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
6435 
6436 typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;
6437 
6438 typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
6439 
6440 typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;
6441 
6442 typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
6443 
6444 typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;
6445 
6446 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
6447 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
6448 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
6449 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
6450 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
6451 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
6452 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
6453 
6454 #ifndef VK_NO_PROTOTYPES
6455 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
6456     VkPhysicalDevice                            physicalDevice,
6457     VkPhysicalDeviceFeatures2*                  pFeatures);
6458 
6459 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
6460     VkPhysicalDevice                            physicalDevice,
6461     VkPhysicalDeviceProperties2*                pProperties);
6462 
6463 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
6464     VkPhysicalDevice                            physicalDevice,
6465     VkFormat                                    format,
6466     VkFormatProperties2*                        pFormatProperties);
6467 
6468 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
6469     VkPhysicalDevice                            physicalDevice,
6470     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
6471     VkImageFormatProperties2*                   pImageFormatProperties);
6472 
6473 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
6474     VkPhysicalDevice                            physicalDevice,
6475     uint32_t*                                   pQueueFamilyPropertyCount,
6476     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
6477 
6478 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
6479     VkPhysicalDevice                            physicalDevice,
6480     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
6481 
6482 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
6483     VkPhysicalDevice                            physicalDevice,
6484     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
6485     uint32_t*                                   pPropertyCount,
6486     VkSparseImageFormatProperties2*             pProperties);
6487 #endif
6488 
6489 
6490 #define VK_KHR_device_group 1
6491 #define VK_KHR_DEVICE_GROUP_SPEC_VERSION  4
6492 #define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"
6493 typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
6494 
6495 typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;
6496 
6497 typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;
6498 
6499 typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;
6500 
6501 typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
6502 
6503 typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;
6504 
6505 typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;
6506 
6507 typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
6508 
6509 typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
6510 
6511 typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;
6512 
6513 typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;
6514 
6515 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
6516 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
6517 typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
6518 
6519 #ifndef VK_NO_PROTOTYPES
6520 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(
6521     VkDevice                                    device,
6522     uint32_t                                    heapIndex,
6523     uint32_t                                    localDeviceIndex,
6524     uint32_t                                    remoteDeviceIndex,
6525     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
6526 
6527 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(
6528     VkCommandBuffer                             commandBuffer,
6529     uint32_t                                    deviceMask);
6530 
6531 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(
6532     VkCommandBuffer                             commandBuffer,
6533     uint32_t                                    baseGroupX,
6534     uint32_t                                    baseGroupY,
6535     uint32_t                                    baseGroupZ,
6536     uint32_t                                    groupCountX,
6537     uint32_t                                    groupCountY,
6538     uint32_t                                    groupCountZ);
6539 #endif
6540 
6541 
6542 #define VK_KHR_shader_draw_parameters 1
6543 #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
6544 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
6545 
6546 
6547 #define VK_KHR_maintenance1 1
6548 #define VK_KHR_MAINTENANCE1_SPEC_VERSION  2
6549 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
6550 typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;
6551 
6552 typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
6553 
6554 #ifndef VK_NO_PROTOTYPES
6555 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
6556     VkDevice                                    device,
6557     VkCommandPool                               commandPool,
6558     VkCommandPoolTrimFlags                      flags);
6559 #endif
6560 
6561 
6562 #define VK_KHR_device_group_creation 1
6563 #define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1
6564 #define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"
6565 #define VK_MAX_DEVICE_GROUP_SIZE_KHR      VK_MAX_DEVICE_GROUP_SIZE
6566 typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
6567 
6568 typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
6569 
6570 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
6571 
6572 #ifndef VK_NO_PROTOTYPES
6573 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(
6574     VkInstance                                  instance,
6575     uint32_t*                                   pPhysicalDeviceGroupCount,
6576     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
6577 #endif
6578 
6579 
6580 #define VK_KHR_external_memory_capabilities 1
6581 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
6582 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
6583 #define VK_LUID_SIZE_KHR                  VK_LUID_SIZE
6584 typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;
6585 
6586 typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;
6587 
6588 typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;
6589 
6590 typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;
6591 
6592 typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
6593 
6594 typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;
6595 
6596 typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
6597 
6598 typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;
6599 
6600 typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
6601 
6602 typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
6603 
6604 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
6605 
6606 #ifndef VK_NO_PROTOTYPES
6607 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
6608     VkPhysicalDevice                            physicalDevice,
6609     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
6610     VkExternalBufferProperties*                 pExternalBufferProperties);
6611 #endif
6612 
6613 
6614 #define VK_KHR_external_memory 1
6615 #define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
6616 #define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
6617 #define VK_QUEUE_FAMILY_EXTERNAL_KHR      VK_QUEUE_FAMILY_EXTERNAL
6618 typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
6619 
6620 typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;
6621 
6622 typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
6623 
6624 
6625 
6626 #define VK_KHR_external_memory_fd 1
6627 #define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
6628 #define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
6629 typedef struct VkImportMemoryFdInfoKHR {
6630     VkStructureType                       sType;
6631     const void*                           pNext;
6632     VkExternalMemoryHandleTypeFlagBits    handleType;
6633     int                                   fd;
6634 } VkImportMemoryFdInfoKHR;
6635 
6636 typedef struct VkMemoryFdPropertiesKHR {
6637     VkStructureType    sType;
6638     void*              pNext;
6639     uint32_t           memoryTypeBits;
6640 } VkMemoryFdPropertiesKHR;
6641 
6642 typedef struct VkMemoryGetFdInfoKHR {
6643     VkStructureType                       sType;
6644     const void*                           pNext;
6645     VkDeviceMemory                        memory;
6646     VkExternalMemoryHandleTypeFlagBits    handleType;
6647 } VkMemoryGetFdInfoKHR;
6648 
6649 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
6650 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
6651 
6652 #ifndef VK_NO_PROTOTYPES
6653 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
6654     VkDevice                                    device,
6655     const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
6656     int*                                        pFd);
6657 
6658 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
6659     VkDevice                                    device,
6660     VkExternalMemoryHandleTypeFlagBits          handleType,
6661     int                                         fd,
6662     VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
6663 #endif
6664 
6665 
6666 #define VK_KHR_external_semaphore_capabilities 1
6667 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
6668 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
6669 typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;
6670 
6671 typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;
6672 
6673 typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;
6674 
6675 typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;
6676 
6677 typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;
6678 
6679 typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
6680 
6681 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
6682 
6683 #ifndef VK_NO_PROTOTYPES
6684 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
6685     VkPhysicalDevice                            physicalDevice,
6686     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
6687     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
6688 #endif
6689 
6690 
6691 #define VK_KHR_external_semaphore 1
6692 #define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
6693 #define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
6694 typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;
6695 
6696 typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;
6697 
6698 typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
6699 
6700 
6701 
6702 #define VK_KHR_external_semaphore_fd 1
6703 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
6704 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
6705 typedef struct VkImportSemaphoreFdInfoKHR {
6706     VkStructureType                          sType;
6707     const void*                              pNext;
6708     VkSemaphore                              semaphore;
6709     VkSemaphoreImportFlags                   flags;
6710     VkExternalSemaphoreHandleTypeFlagBits    handleType;
6711     int                                      fd;
6712 } VkImportSemaphoreFdInfoKHR;
6713 
6714 typedef struct VkSemaphoreGetFdInfoKHR {
6715     VkStructureType                          sType;
6716     const void*                              pNext;
6717     VkSemaphore                              semaphore;
6718     VkExternalSemaphoreHandleTypeFlagBits    handleType;
6719 } VkSemaphoreGetFdInfoKHR;
6720 
6721 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
6722 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
6723 
6724 #ifndef VK_NO_PROTOTYPES
6725 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
6726     VkDevice                                    device,
6727     const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
6728 
6729 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
6730     VkDevice                                    device,
6731     const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
6732     int*                                        pFd);
6733 #endif
6734 
6735 
6736 #define VK_KHR_push_descriptor 1
6737 #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
6738 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
6739 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
6740     VkStructureType    sType;
6741     void*              pNext;
6742     uint32_t           maxPushDescriptors;
6743 } VkPhysicalDevicePushDescriptorPropertiesKHR;
6744 
6745 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
6746 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
6747 
6748 #ifndef VK_NO_PROTOTYPES
6749 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
6750     VkCommandBuffer                             commandBuffer,
6751     VkPipelineBindPoint                         pipelineBindPoint,
6752     VkPipelineLayout                            layout,
6753     uint32_t                                    set,
6754     uint32_t                                    descriptorWriteCount,
6755     const VkWriteDescriptorSet*                 pDescriptorWrites);
6756 
6757 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
6758     VkCommandBuffer                             commandBuffer,
6759     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
6760     VkPipelineLayout                            layout,
6761     uint32_t                                    set,
6762     const void*                                 pData);
6763 #endif
6764 
6765 
6766 #define VK_KHR_shader_float16_int8 1
6767 #define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
6768 #define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
6769 typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
6770 
6771 typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR;
6772 
6773 
6774 
6775 #define VK_KHR_16bit_storage 1
6776 #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
6777 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
6778 typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;
6779 
6780 
6781 
6782 #define VK_KHR_incremental_present 1
6783 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2
6784 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
6785 typedef struct VkRectLayerKHR {
6786     VkOffset2D    offset;
6787     VkExtent2D    extent;
6788     uint32_t      layer;
6789 } VkRectLayerKHR;
6790 
6791 typedef struct VkPresentRegionKHR {
6792     uint32_t                 rectangleCount;
6793     const VkRectLayerKHR*    pRectangles;
6794 } VkPresentRegionKHR;
6795 
6796 typedef struct VkPresentRegionsKHR {
6797     VkStructureType              sType;
6798     const void*                  pNext;
6799     uint32_t                     swapchainCount;
6800     const VkPresentRegionKHR*    pRegions;
6801 } VkPresentRegionsKHR;
6802 
6803 
6804 
6805 #define VK_KHR_descriptor_update_template 1
6806 typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;
6807 
6808 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
6809 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
6810 typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;
6811 
6812 typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
6813 
6814 typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
6815 
6816 typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;
6817 
6818 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
6819 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
6820 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
6821 
6822 #ifndef VK_NO_PROTOTYPES
6823 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
6824     VkDevice                                    device,
6825     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
6826     const VkAllocationCallbacks*                pAllocator,
6827     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
6828 
6829 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
6830     VkDevice                                    device,
6831     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
6832     const VkAllocationCallbacks*                pAllocator);
6833 
6834 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
6835     VkDevice                                    device,
6836     VkDescriptorSet                             descriptorSet,
6837     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
6838     const void*                                 pData);
6839 #endif
6840 
6841 
6842 #define VK_KHR_imageless_framebuffer 1
6843 #define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1
6844 #define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer"
6845 typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
6846 
6847 typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR;
6848 
6849 typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR;
6850 
6851 typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR;
6852 
6853 
6854 
6855 #define VK_KHR_create_renderpass2 1
6856 #define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1
6857 #define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"
6858 typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR;
6859 
6860 typedef VkAttachmentDescription2 VkAttachmentDescription2KHR;
6861 
6862 typedef VkAttachmentReference2 VkAttachmentReference2KHR;
6863 
6864 typedef VkSubpassDescription2 VkSubpassDescription2KHR;
6865 
6866 typedef VkSubpassDependency2 VkSubpassDependency2KHR;
6867 
6868 typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR;
6869 
6870 typedef VkSubpassEndInfo VkSubpassEndInfoKHR;
6871 
6872 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
6873 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfo*      pSubpassBeginInfo);
6874 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo*      pSubpassBeginInfo, const VkSubpassEndInfo*        pSubpassEndInfo);
6875 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo*        pSubpassEndInfo);
6876 
6877 #ifndef VK_NO_PROTOTYPES
6878 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(
6879     VkDevice                                    device,
6880     const VkRenderPassCreateInfo2*              pCreateInfo,
6881     const VkAllocationCallbacks*                pAllocator,
6882     VkRenderPass*                               pRenderPass);
6883 
6884 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(
6885     VkCommandBuffer                             commandBuffer,
6886     const VkRenderPassBeginInfo*                pRenderPassBegin,
6887     const VkSubpassBeginInfo*                   pSubpassBeginInfo);
6888 
6889 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(
6890     VkCommandBuffer                             commandBuffer,
6891     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
6892     const VkSubpassEndInfo*                     pSubpassEndInfo);
6893 
6894 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(
6895     VkCommandBuffer                             commandBuffer,
6896     const VkSubpassEndInfo*                     pSubpassEndInfo);
6897 #endif
6898 
6899 
6900 #define VK_KHR_shared_presentable_image 1
6901 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
6902 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
6903 typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
6904     VkStructureType      sType;
6905     void*                pNext;
6906     VkImageUsageFlags    sharedPresentSupportedUsageFlags;
6907 } VkSharedPresentSurfaceCapabilitiesKHR;
6908 
6909 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
6910 
6911 #ifndef VK_NO_PROTOTYPES
6912 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
6913     VkDevice                                    device,
6914     VkSwapchainKHR                              swapchain);
6915 #endif
6916 
6917 
6918 #define VK_KHR_external_fence_capabilities 1
6919 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
6920 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
6921 typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;
6922 
6923 typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;
6924 
6925 typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;
6926 
6927 typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;
6928 
6929 typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;
6930 
6931 typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
6932 
6933 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
6934 
6935 #ifndef VK_NO_PROTOTYPES
6936 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
6937     VkPhysicalDevice                            physicalDevice,
6938     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
6939     VkExternalFenceProperties*                  pExternalFenceProperties);
6940 #endif
6941 
6942 
6943 #define VK_KHR_external_fence 1
6944 #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
6945 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
6946 typedef VkFenceImportFlags VkFenceImportFlagsKHR;
6947 
6948 typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;
6949 
6950 typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
6951 
6952 
6953 
6954 #define VK_KHR_external_fence_fd 1
6955 #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
6956 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
6957 typedef struct VkImportFenceFdInfoKHR {
6958     VkStructureType                      sType;
6959     const void*                          pNext;
6960     VkFence                              fence;
6961     VkFenceImportFlags                   flags;
6962     VkExternalFenceHandleTypeFlagBits    handleType;
6963     int                                  fd;
6964 } VkImportFenceFdInfoKHR;
6965 
6966 typedef struct VkFenceGetFdInfoKHR {
6967     VkStructureType                      sType;
6968     const void*                          pNext;
6969     VkFence                              fence;
6970     VkExternalFenceHandleTypeFlagBits    handleType;
6971 } VkFenceGetFdInfoKHR;
6972 
6973 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
6974 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
6975 
6976 #ifndef VK_NO_PROTOTYPES
6977 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
6978     VkDevice                                    device,
6979     const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
6980 
6981 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
6982     VkDevice                                    device,
6983     const VkFenceGetFdInfoKHR*                  pGetFdInfo,
6984     int*                                        pFd);
6985 #endif
6986 
6987 
6988 #define VK_KHR_performance_query 1
6989 #define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1
6990 #define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"
6991 
6992 typedef enum VkPerformanceCounterUnitKHR {
6993     VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
6994     VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
6995     VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
6996     VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
6997     VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
6998     VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
6999     VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
7000     VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
7001     VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
7002     VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
7003     VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
7004     VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF
7005 } VkPerformanceCounterUnitKHR;
7006 
7007 typedef enum VkPerformanceCounterScopeKHR {
7008     VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0,
7009     VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1,
7010     VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2,
7011     VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR,
7012     VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR,
7013     VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR,
7014     VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF
7015 } VkPerformanceCounterScopeKHR;
7016 
7017 typedef enum VkPerformanceCounterStorageKHR {
7018     VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
7019     VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
7020     VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
7021     VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
7022     VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
7023     VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
7024     VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF
7025 } VkPerformanceCounterStorageKHR;
7026 
7027 typedef enum VkPerformanceCounterDescriptionFlagBitsKHR {
7028     VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001,
7029     VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002,
7030     VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR,
7031     VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR,
7032     VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
7033 } VkPerformanceCounterDescriptionFlagBitsKHR;
7034 typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
7035 
7036 typedef enum VkAcquireProfilingLockFlagBitsKHR {
7037     VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
7038 } VkAcquireProfilingLockFlagBitsKHR;
7039 typedef VkFlags VkAcquireProfilingLockFlagsKHR;
7040 typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
7041     VkStructureType    sType;
7042     void*              pNext;
7043     VkBool32           performanceCounterQueryPools;
7044     VkBool32           performanceCounterMultipleQueryPools;
7045 } VkPhysicalDevicePerformanceQueryFeaturesKHR;
7046 
7047 typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
7048     VkStructureType    sType;
7049     void*              pNext;
7050     VkBool32           allowCommandBufferQueryCopies;
7051 } VkPhysicalDevicePerformanceQueryPropertiesKHR;
7052 
7053 typedef struct VkPerformanceCounterKHR {
7054     VkStructureType                   sType;
7055     const void*                       pNext;
7056     VkPerformanceCounterUnitKHR       unit;
7057     VkPerformanceCounterScopeKHR      scope;
7058     VkPerformanceCounterStorageKHR    storage;
7059     uint8_t                           uuid[VK_UUID_SIZE];
7060 } VkPerformanceCounterKHR;
7061 
7062 typedef struct VkPerformanceCounterDescriptionKHR {
7063     VkStructureType                            sType;
7064     const void*                                pNext;
7065     VkPerformanceCounterDescriptionFlagsKHR    flags;
7066     char                                       name[VK_MAX_DESCRIPTION_SIZE];
7067     char                                       category[VK_MAX_DESCRIPTION_SIZE];
7068     char                                       description[VK_MAX_DESCRIPTION_SIZE];
7069 } VkPerformanceCounterDescriptionKHR;
7070 
7071 typedef struct VkQueryPoolPerformanceCreateInfoKHR {
7072     VkStructureType    sType;
7073     const void*        pNext;
7074     uint32_t           queueFamilyIndex;
7075     uint32_t           counterIndexCount;
7076     const uint32_t*    pCounterIndices;
7077 } VkQueryPoolPerformanceCreateInfoKHR;
7078 
7079 typedef union VkPerformanceCounterResultKHR {
7080     int32_t     int32;
7081     int64_t     int64;
7082     uint32_t    uint32;
7083     uint64_t    uint64;
7084     float       float32;
7085     double      float64;
7086 } VkPerformanceCounterResultKHR;
7087 
7088 typedef struct VkAcquireProfilingLockInfoKHR {
7089     VkStructureType                   sType;
7090     const void*                       pNext;
7091     VkAcquireProfilingLockFlagsKHR    flags;
7092     uint64_t                          timeout;
7093 } VkAcquireProfilingLockInfoKHR;
7094 
7095 typedef struct VkPerformanceQuerySubmitInfoKHR {
7096     VkStructureType    sType;
7097     const void*        pNext;
7098     uint32_t           counterPassIndex;
7099 } VkPerformanceQuerySubmitInfoKHR;
7100 
7101 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
7102 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses);
7103 typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);
7104 typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device);
7105 
7106 #ifndef VK_NO_PROTOTYPES
7107 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
7108     VkPhysicalDevice                            physicalDevice,
7109     uint32_t                                    queueFamilyIndex,
7110     uint32_t*                                   pCounterCount,
7111     VkPerformanceCounterKHR*                    pCounters,
7112     VkPerformanceCounterDescriptionKHR*         pCounterDescriptions);
7113 
7114 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
7115     VkPhysicalDevice                            physicalDevice,
7116     const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
7117     uint32_t*                                   pNumPasses);
7118 
7119 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(
7120     VkDevice                                    device,
7121     const VkAcquireProfilingLockInfoKHR*        pInfo);
7122 
7123 VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(
7124     VkDevice                                    device);
7125 #endif
7126 
7127 
7128 #define VK_KHR_maintenance2 1
7129 #define VK_KHR_MAINTENANCE2_SPEC_VERSION  1
7130 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"
7131 typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;
7132 
7133 typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;
7134 
7135 typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;
7136 
7137 typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;
7138 
7139 typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;
7140 
7141 typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
7142 
7143 typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;
7144 
7145 
7146 
7147 #define VK_KHR_get_surface_capabilities2 1
7148 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
7149 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
7150 typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
7151     VkStructureType    sType;
7152     const void*        pNext;
7153     VkSurfaceKHR       surface;
7154 } VkPhysicalDeviceSurfaceInfo2KHR;
7155 
7156 typedef struct VkSurfaceCapabilities2KHR {
7157     VkStructureType             sType;
7158     void*                       pNext;
7159     VkSurfaceCapabilitiesKHR    surfaceCapabilities;
7160 } VkSurfaceCapabilities2KHR;
7161 
7162 typedef struct VkSurfaceFormat2KHR {
7163     VkStructureType       sType;
7164     void*                 pNext;
7165     VkSurfaceFormatKHR    surfaceFormat;
7166 } VkSurfaceFormat2KHR;
7167 
7168 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
7169 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
7170 
7171 #ifndef VK_NO_PROTOTYPES
7172 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
7173     VkPhysicalDevice                            physicalDevice,
7174     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
7175     VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
7176 
7177 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
7178     VkPhysicalDevice                            physicalDevice,
7179     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
7180     uint32_t*                                   pSurfaceFormatCount,
7181     VkSurfaceFormat2KHR*                        pSurfaceFormats);
7182 #endif
7183 
7184 
7185 #define VK_KHR_variable_pointers 1
7186 #define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
7187 #define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
7188 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;
7189 
7190 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;
7191 
7192 
7193 
7194 #define VK_KHR_get_display_properties2 1
7195 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1
7196 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"
7197 typedef struct VkDisplayProperties2KHR {
7198     VkStructureType           sType;
7199     void*                     pNext;
7200     VkDisplayPropertiesKHR    displayProperties;
7201 } VkDisplayProperties2KHR;
7202 
7203 typedef struct VkDisplayPlaneProperties2KHR {
7204     VkStructureType                sType;
7205     void*                          pNext;
7206     VkDisplayPlanePropertiesKHR    displayPlaneProperties;
7207 } VkDisplayPlaneProperties2KHR;
7208 
7209 typedef struct VkDisplayModeProperties2KHR {
7210     VkStructureType               sType;
7211     void*                         pNext;
7212     VkDisplayModePropertiesKHR    displayModeProperties;
7213 } VkDisplayModeProperties2KHR;
7214 
7215 typedef struct VkDisplayPlaneInfo2KHR {
7216     VkStructureType     sType;
7217     const void*         pNext;
7218     VkDisplayModeKHR    mode;
7219     uint32_t            planeIndex;
7220 } VkDisplayPlaneInfo2KHR;
7221 
7222 typedef struct VkDisplayPlaneCapabilities2KHR {
7223     VkStructureType                  sType;
7224     void*                            pNext;
7225     VkDisplayPlaneCapabilitiesKHR    capabilities;
7226 } VkDisplayPlaneCapabilities2KHR;
7227 
7228 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties);
7229 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties);
7230 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties);
7231 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities);
7232 
7233 #ifndef VK_NO_PROTOTYPES
7234 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(
7235     VkPhysicalDevice                            physicalDevice,
7236     uint32_t*                                   pPropertyCount,
7237     VkDisplayProperties2KHR*                    pProperties);
7238 
7239 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
7240     VkPhysicalDevice                            physicalDevice,
7241     uint32_t*                                   pPropertyCount,
7242     VkDisplayPlaneProperties2KHR*               pProperties);
7243 
7244 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(
7245     VkPhysicalDevice                            physicalDevice,
7246     VkDisplayKHR                                display,
7247     uint32_t*                                   pPropertyCount,
7248     VkDisplayModeProperties2KHR*                pProperties);
7249 
7250 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(
7251     VkPhysicalDevice                            physicalDevice,
7252     const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
7253     VkDisplayPlaneCapabilities2KHR*             pCapabilities);
7254 #endif
7255 
7256 
7257 #define VK_KHR_dedicated_allocation 1
7258 #define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
7259 #define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
7260 typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
7261 
7262 typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
7263 
7264 
7265 
7266 #define VK_KHR_storage_buffer_storage_class 1
7267 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
7268 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
7269 
7270 
7271 #define VK_KHR_relaxed_block_layout 1
7272 #define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
7273 #define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
7274 
7275 
7276 #define VK_KHR_get_memory_requirements2 1
7277 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
7278 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
7279 typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
7280 
7281 typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
7282 
7283 typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
7284 
7285 typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
7286 
7287 typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
7288 
7289 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
7290 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
7291 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
7292 
7293 #ifndef VK_NO_PROTOTYPES
7294 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
7295     VkDevice                                    device,
7296     const VkImageMemoryRequirementsInfo2*       pInfo,
7297     VkMemoryRequirements2*                      pMemoryRequirements);
7298 
7299 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
7300     VkDevice                                    device,
7301     const VkBufferMemoryRequirementsInfo2*      pInfo,
7302     VkMemoryRequirements2*                      pMemoryRequirements);
7303 
7304 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
7305     VkDevice                                    device,
7306     const VkImageSparseMemoryRequirementsInfo2* pInfo,
7307     uint32_t*                                   pSparseMemoryRequirementCount,
7308     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
7309 #endif
7310 
7311 
7312 #define VK_KHR_image_format_list 1
7313 #define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
7314 #define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"
7315 typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR;
7316 
7317 
7318 
7319 #define VK_KHR_sampler_ycbcr_conversion 1
7320 typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
7321 
7322 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14
7323 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
7324 typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
7325 
7326 typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
7327 
7328 typedef VkChromaLocation VkChromaLocationKHR;
7329 
7330 typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;
7331 
7332 typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
7333 
7334 typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
7335 
7336 typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;
7337 
7338 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
7339 
7340 typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;
7341 
7342 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
7343 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
7344 
7345 #ifndef VK_NO_PROTOTYPES
7346 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(
7347     VkDevice                                    device,
7348     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
7349     const VkAllocationCallbacks*                pAllocator,
7350     VkSamplerYcbcrConversion*                   pYcbcrConversion);
7351 
7352 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(
7353     VkDevice                                    device,
7354     VkSamplerYcbcrConversion                    ycbcrConversion,
7355     const VkAllocationCallbacks*                pAllocator);
7356 #endif
7357 
7358 
7359 #define VK_KHR_bind_memory2 1
7360 #define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1
7361 #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"
7362 typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
7363 
7364 typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
7365 
7366 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
7367 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
7368 
7369 #ifndef VK_NO_PROTOTYPES
7370 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(
7371     VkDevice                                    device,
7372     uint32_t                                    bindInfoCount,
7373     const VkBindBufferMemoryInfo*               pBindInfos);
7374 
7375 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(
7376     VkDevice                                    device,
7377     uint32_t                                    bindInfoCount,
7378     const VkBindImageMemoryInfo*                pBindInfos);
7379 #endif
7380 
7381 
7382 #define VK_KHR_maintenance3 1
7383 #define VK_KHR_MAINTENANCE3_SPEC_VERSION  1
7384 #define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3"
7385 typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
7386 
7387 typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
7388 
7389 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
7390 
7391 #ifndef VK_NO_PROTOTYPES
7392 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(
7393     VkDevice                                    device,
7394     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
7395     VkDescriptorSetLayoutSupport*               pSupport);
7396 #endif
7397 
7398 
7399 #define VK_KHR_draw_indirect_count 1
7400 #define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
7401 #define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count"
7402 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
7403 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
7404 
7405 #ifndef VK_NO_PROTOTYPES
7406 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(
7407     VkCommandBuffer                             commandBuffer,
7408     VkBuffer                                    buffer,
7409     VkDeviceSize                                offset,
7410     VkBuffer                                    countBuffer,
7411     VkDeviceSize                                countBufferOffset,
7412     uint32_t                                    maxDrawCount,
7413     uint32_t                                    stride);
7414 
7415 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(
7416     VkCommandBuffer                             commandBuffer,
7417     VkBuffer                                    buffer,
7418     VkDeviceSize                                offset,
7419     VkBuffer                                    countBuffer,
7420     VkDeviceSize                                countBufferOffset,
7421     uint32_t                                    maxDrawCount,
7422     uint32_t                                    stride);
7423 #endif
7424 
7425 
7426 #define VK_KHR_shader_subgroup_extended_types 1
7427 #define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1
7428 #define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types"
7429 typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
7430 
7431 
7432 
7433 #define VK_KHR_8bit_storage 1
7434 #define VK_KHR_8BIT_STORAGE_SPEC_VERSION  1
7435 #define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
7436 typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR;
7437 
7438 
7439 
7440 #define VK_KHR_shader_atomic_int64 1
7441 #define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1
7442 #define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"
7443 typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;
7444 
7445 
7446 
7447 #define VK_KHR_shader_clock 1
7448 #define VK_KHR_SHADER_CLOCK_SPEC_VERSION  1
7449 #define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
7450 typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
7451     VkStructureType    sType;
7452     void*              pNext;
7453     VkBool32           shaderSubgroupClock;
7454     VkBool32           shaderDeviceClock;
7455 } VkPhysicalDeviceShaderClockFeaturesKHR;
7456 
7457 
7458 
7459 #define VK_KHR_driver_properties 1
7460 #define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1
7461 #define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties"
7462 #define VK_MAX_DRIVER_NAME_SIZE_KHR       VK_MAX_DRIVER_NAME_SIZE
7463 #define VK_MAX_DRIVER_INFO_SIZE_KHR       VK_MAX_DRIVER_INFO_SIZE
7464 typedef VkDriverId VkDriverIdKHR;
7465 
7466 typedef VkConformanceVersion VkConformanceVersionKHR;
7467 
7468 typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR;
7469 
7470 
7471 
7472 #define VK_KHR_shader_float_controls 1
7473 #define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4
7474 #define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls"
7475 typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR;
7476 
7477 typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR;
7478 
7479 
7480 
7481 #define VK_KHR_depth_stencil_resolve 1
7482 #define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1
7483 #define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve"
7484 typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR;
7485 
7486 typedef VkResolveModeFlags VkResolveModeFlagsKHR;
7487 
7488 typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR;
7489 
7490 typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR;
7491 
7492 
7493 
7494 #define VK_KHR_swapchain_mutable_format 1
7495 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1
7496 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format"
7497 
7498 
7499 #define VK_KHR_timeline_semaphore 1
7500 #define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2
7501 #define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore"
7502 typedef VkSemaphoreType VkSemaphoreTypeKHR;
7503 
7504 typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR;
7505 
7506 typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR;
7507 
7508 typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;
7509 
7510 typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR;
7511 
7512 typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR;
7513 
7514 typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR;
7515 
7516 typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR;
7517 
7518 typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR;
7519 
7520 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
7521 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
7522 typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
7523 
7524 #ifndef VK_NO_PROTOTYPES
7525 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(
7526     VkDevice                                    device,
7527     VkSemaphore                                 semaphore,
7528     uint64_t*                                   pValue);
7529 
7530 VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(
7531     VkDevice                                    device,
7532     const VkSemaphoreWaitInfo*                  pWaitInfo,
7533     uint64_t                                    timeout);
7534 
7535 VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(
7536     VkDevice                                    device,
7537     const VkSemaphoreSignalInfo*                pSignalInfo);
7538 #endif
7539 
7540 
7541 #define VK_KHR_vulkan_memory_model 1
7542 #define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3
7543 #define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"
7544 typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
7545 
7546 
7547 
7548 #define VK_KHR_shader_terminate_invocation 1
7549 #define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1
7550 #define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation"
7551 typedef struct VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR {
7552     VkStructureType    sType;
7553     void*              pNext;
7554     VkBool32           shaderTerminateInvocation;
7555 } VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR;
7556 
7557 
7558 
7559 #define VK_KHR_fragment_shading_rate 1
7560 #define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 1
7561 #define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate"
7562 
7563 typedef enum VkFragmentShadingRateCombinerOpKHR {
7564     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0,
7565     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1,
7566     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2,
7567     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3,
7568     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4,
7569     VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF
7570 } VkFragmentShadingRateCombinerOpKHR;
7571 typedef struct VkFragmentShadingRateAttachmentInfoKHR {
7572     VkStructureType                  sType;
7573     const void*                      pNext;
7574     const VkAttachmentReference2*    pFragmentShadingRateAttachment;
7575     VkExtent2D                       shadingRateAttachmentTexelSize;
7576 } VkFragmentShadingRateAttachmentInfoKHR;
7577 
7578 typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR {
7579     VkStructureType                       sType;
7580     const void*                           pNext;
7581     VkExtent2D                            fragmentSize;
7582     VkFragmentShadingRateCombinerOpKHR    combinerOps[2];
7583 } VkPipelineFragmentShadingRateStateCreateInfoKHR;
7584 
7585 typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
7586     VkStructureType    sType;
7587     void*              pNext;
7588     VkBool32           pipelineFragmentShadingRate;
7589     VkBool32           primitiveFragmentShadingRate;
7590     VkBool32           attachmentFragmentShadingRate;
7591 } VkPhysicalDeviceFragmentShadingRateFeaturesKHR;
7592 
7593 typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
7594     VkStructureType          sType;
7595     void*                    pNext;
7596     VkExtent2D               minFragmentShadingRateAttachmentTexelSize;
7597     VkExtent2D               maxFragmentShadingRateAttachmentTexelSize;
7598     uint32_t                 maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
7599     VkBool32                 primitiveFragmentShadingRateWithMultipleViewports;
7600     VkBool32                 layeredShadingRateAttachments;
7601     VkBool32                 fragmentShadingRateNonTrivialCombinerOps;
7602     VkExtent2D               maxFragmentSize;
7603     uint32_t                 maxFragmentSizeAspectRatio;
7604     uint32_t                 maxFragmentShadingRateCoverageSamples;
7605     VkSampleCountFlagBits    maxFragmentShadingRateRasterizationSamples;
7606     VkBool32                 fragmentShadingRateWithShaderDepthStencilWrites;
7607     VkBool32                 fragmentShadingRateWithSampleMask;
7608     VkBool32                 fragmentShadingRateWithShaderSampleMask;
7609     VkBool32                 fragmentShadingRateWithConservativeRasterization;
7610     VkBool32                 fragmentShadingRateWithFragmentShaderInterlock;
7611     VkBool32                 fragmentShadingRateWithCustomSampleLocations;
7612     VkBool32                 fragmentShadingRateStrictMultiplyCombiner;
7613 } VkPhysicalDeviceFragmentShadingRatePropertiesKHR;
7614 
7615 typedef struct VkPhysicalDeviceFragmentShadingRateKHR {
7616     VkStructureType       sType;
7617     void*                 pNext;
7618     VkSampleCountFlags    sampleCounts;
7619     VkExtent2D            fragmentSize;
7620 } VkPhysicalDeviceFragmentShadingRateKHR;
7621 
7622 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);
7623 typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer           commandBuffer, const VkExtent2D*                           pFragmentSize, const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
7624 
7625 #ifndef VK_NO_PROTOTYPES
7626 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(
7627     VkPhysicalDevice                            physicalDevice,
7628     uint32_t*                                   pFragmentShadingRateCount,
7629     VkPhysicalDeviceFragmentShadingRateKHR*     pFragmentShadingRates);
7630 
7631 VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(
7632     VkCommandBuffer                             commandBuffer,
7633     const VkExtent2D*                           pFragmentSize,
7634     const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
7635 #endif
7636 
7637 
7638 #define VK_KHR_spirv_1_4 1
7639 #define VK_KHR_SPIRV_1_4_SPEC_VERSION     1
7640 #define VK_KHR_SPIRV_1_4_EXTENSION_NAME   "VK_KHR_spirv_1_4"
7641 
7642 
7643 #define VK_KHR_surface_protected_capabilities 1
7644 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
7645 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities"
7646 typedef struct VkSurfaceProtectedCapabilitiesKHR {
7647     VkStructureType    sType;
7648     const void*        pNext;
7649     VkBool32           supportsProtected;
7650 } VkSurfaceProtectedCapabilitiesKHR;
7651 
7652 
7653 
7654 #define VK_KHR_separate_depth_stencil_layouts 1
7655 #define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1
7656 #define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts"
7657 typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
7658 
7659 typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR;
7660 
7661 typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR;
7662 
7663 
7664 
7665 #define VK_KHR_uniform_buffer_standard_layout 1
7666 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
7667 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout"
7668 typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
7669 
7670 
7671 
7672 #define VK_KHR_buffer_device_address 1
7673 #define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1
7674 #define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address"
7675 typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;
7676 
7677 typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR;
7678 
7679 typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR;
7680 
7681 typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
7682 
7683 typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR;
7684 
7685 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
7686 typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
7687 typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
7688 
7689 #ifndef VK_NO_PROTOTYPES
7690 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(
7691     VkDevice                                    device,
7692     const VkBufferDeviceAddressInfo*            pInfo);
7693 
7694 VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(
7695     VkDevice                                    device,
7696     const VkBufferDeviceAddressInfo*            pInfo);
7697 
7698 VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(
7699     VkDevice                                    device,
7700     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
7701 #endif
7702 
7703 
7704 #define VK_KHR_deferred_host_operations 1
7705 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR)
7706 #define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 4
7707 #define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations"
7708 typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation);
7709 typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator);
7710 typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation);
7711 typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation);
7712 typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation);
7713 
7714 #ifndef VK_NO_PROTOTYPES
7715 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(
7716     VkDevice                                    device,
7717     const VkAllocationCallbacks*                pAllocator,
7718     VkDeferredOperationKHR*                     pDeferredOperation);
7719 
7720 VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(
7721     VkDevice                                    device,
7722     VkDeferredOperationKHR                      operation,
7723     const VkAllocationCallbacks*                pAllocator);
7724 
7725 VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(
7726     VkDevice                                    device,
7727     VkDeferredOperationKHR                      operation);
7728 
7729 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(
7730     VkDevice                                    device,
7731     VkDeferredOperationKHR                      operation);
7732 
7733 VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(
7734     VkDevice                                    device,
7735     VkDeferredOperationKHR                      operation);
7736 #endif
7737 
7738 
7739 #define VK_KHR_pipeline_executable_properties 1
7740 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
7741 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
7742 
7743 typedef enum VkPipelineExecutableStatisticFormatKHR {
7744     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
7745     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
7746     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
7747     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
7748     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF
7749 } VkPipelineExecutableStatisticFormatKHR;
7750 typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
7751     VkStructureType    sType;
7752     void*              pNext;
7753     VkBool32           pipelineExecutableInfo;
7754 } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
7755 
7756 typedef struct VkPipelineInfoKHR {
7757     VkStructureType    sType;
7758     const void*        pNext;
7759     VkPipeline         pipeline;
7760 } VkPipelineInfoKHR;
7761 
7762 typedef struct VkPipelineExecutablePropertiesKHR {
7763     VkStructureType       sType;
7764     void*                 pNext;
7765     VkShaderStageFlags    stages;
7766     char                  name[VK_MAX_DESCRIPTION_SIZE];
7767     char                  description[VK_MAX_DESCRIPTION_SIZE];
7768     uint32_t              subgroupSize;
7769 } VkPipelineExecutablePropertiesKHR;
7770 
7771 typedef struct VkPipelineExecutableInfoKHR {
7772     VkStructureType    sType;
7773     const void*        pNext;
7774     VkPipeline         pipeline;
7775     uint32_t           executableIndex;
7776 } VkPipelineExecutableInfoKHR;
7777 
7778 typedef union VkPipelineExecutableStatisticValueKHR {
7779     VkBool32    b32;
7780     int64_t     i64;
7781     uint64_t    u64;
7782     double      f64;
7783 } VkPipelineExecutableStatisticValueKHR;
7784 
7785 typedef struct VkPipelineExecutableStatisticKHR {
7786     VkStructureType                           sType;
7787     void*                                     pNext;
7788     char                                      name[VK_MAX_DESCRIPTION_SIZE];
7789     char                                      description[VK_MAX_DESCRIPTION_SIZE];
7790     VkPipelineExecutableStatisticFormatKHR    format;
7791     VkPipelineExecutableStatisticValueKHR     value;
7792 } VkPipelineExecutableStatisticKHR;
7793 
7794 typedef struct VkPipelineExecutableInternalRepresentationKHR {
7795     VkStructureType    sType;
7796     void*              pNext;
7797     char               name[VK_MAX_DESCRIPTION_SIZE];
7798     char               description[VK_MAX_DESCRIPTION_SIZE];
7799     VkBool32           isText;
7800     size_t             dataSize;
7801     void*              pData;
7802 } VkPipelineExecutableInternalRepresentationKHR;
7803 
7804 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
7805 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
7806 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
7807 
7808 #ifndef VK_NO_PROTOTYPES
7809 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(
7810     VkDevice                                    device,
7811     const VkPipelineInfoKHR*                    pPipelineInfo,
7812     uint32_t*                                   pExecutableCount,
7813     VkPipelineExecutablePropertiesKHR*          pProperties);
7814 
7815 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(
7816     VkDevice                                    device,
7817     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
7818     uint32_t*                                   pStatisticCount,
7819     VkPipelineExecutableStatisticKHR*           pStatistics);
7820 
7821 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(
7822     VkDevice                                    device,
7823     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
7824     uint32_t*                                   pInternalRepresentationCount,
7825     VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
7826 #endif
7827 
7828 
7829 #define VK_KHR_pipeline_library 1
7830 #define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1
7831 #define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library"
7832 typedef struct VkPipelineLibraryCreateInfoKHR {
7833     VkStructureType      sType;
7834     const void*          pNext;
7835     uint32_t             libraryCount;
7836     const VkPipeline*    pLibraries;
7837 } VkPipelineLibraryCreateInfoKHR;
7838 
7839 
7840 
7841 #define VK_KHR_shader_non_semantic_info 1
7842 #define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1
7843 #define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info"
7844 
7845 
7846 #define VK_KHR_synchronization2 1
7847 typedef uint64_t VkFlags64;
7848 #define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1
7849 #define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2"
7850 typedef VkFlags64 VkPipelineStageFlags2KHR;
7851 
7852 // Flag bits for VkPipelineStageFlagBits2KHR
7853 typedef VkFlags64 VkPipelineStageFlagBits2KHR;
7854 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL;
7855 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL;
7856 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL;
7857 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL;
7858 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL;
7859 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL;
7860 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL;
7861 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL;
7862 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL;
7863 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL;
7864 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL;
7865 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL;
7866 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL;
7867 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL;
7868 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000;
7869 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL;
7870 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL;
7871 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL;
7872 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL;
7873 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL;
7874 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL;
7875 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL;
7876 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL;
7877 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL;
7878 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL;
7879 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL;
7880 #ifdef VK_ENABLE_BETA_EXTENSIONS
7881 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL;
7882 #endif
7883 #ifdef VK_ENABLE_BETA_EXTENSIONS
7884 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL;
7885 #endif
7886 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL;
7887 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL;
7888 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL;
7889 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL;
7890 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000;
7891 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL;
7892 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL;
7893 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000;
7894 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000;
7895 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL;
7896 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL;
7897 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL;
7898 static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL;
7899 
7900 typedef VkFlags64 VkAccessFlags2KHR;
7901 
7902 // Flag bits for VkAccessFlagBits2KHR
7903 typedef VkFlags64 VkAccessFlagBits2KHR;
7904 static const VkAccessFlagBits2KHR VK_ACCESS_2_NONE_KHR = 0ULL;
7905 static const VkAccessFlagBits2KHR VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL;
7906 static const VkAccessFlagBits2KHR VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL;
7907 static const VkAccessFlagBits2KHR VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL;
7908 static const VkAccessFlagBits2KHR VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL;
7909 static const VkAccessFlagBits2KHR VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL;
7910 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL;
7911 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL;
7912 static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL;
7913 static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL;
7914 static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL;
7915 static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL;
7916 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL;
7917 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL;
7918 static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL;
7919 static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL;
7920 static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL;
7921 static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL;
7922 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL;
7923 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL;
7924 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL;
7925 #ifdef VK_ENABLE_BETA_EXTENSIONS
7926 static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL;
7927 #endif
7928 #ifdef VK_ENABLE_BETA_EXTENSIONS
7929 static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL;
7930 #endif
7931 #ifdef VK_ENABLE_BETA_EXTENSIONS
7932 static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL;
7933 #endif
7934 #ifdef VK_ENABLE_BETA_EXTENSIONS
7935 static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL;
7936 #endif
7937 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL;
7938 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL;
7939 static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL;
7940 static const VkAccessFlagBits2KHR VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL;
7941 static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL;
7942 static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL;
7943 static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL;
7944 static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000;
7945 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL;
7946 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL;
7947 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000;
7948 static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000;
7949 static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL;
7950 static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL;
7951 
7952 
7953 typedef enum VkSubmitFlagBitsKHR {
7954     VK_SUBMIT_PROTECTED_BIT_KHR = 0x00000001,
7955     VK_SUBMIT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
7956 } VkSubmitFlagBitsKHR;
7957 typedef VkFlags VkSubmitFlagsKHR;
7958 typedef struct VkMemoryBarrier2KHR {
7959     VkStructureType             sType;
7960     const void*                 pNext;
7961     VkPipelineStageFlags2KHR    srcStageMask;
7962     VkAccessFlags2KHR           srcAccessMask;
7963     VkPipelineStageFlags2KHR    dstStageMask;
7964     VkAccessFlags2KHR           dstAccessMask;
7965 } VkMemoryBarrier2KHR;
7966 
7967 typedef struct VkBufferMemoryBarrier2KHR {
7968     VkStructureType             sType;
7969     const void*                 pNext;
7970     VkPipelineStageFlags2KHR    srcStageMask;
7971     VkAccessFlags2KHR           srcAccessMask;
7972     VkPipelineStageFlags2KHR    dstStageMask;
7973     VkAccessFlags2KHR           dstAccessMask;
7974     uint32_t                    srcQueueFamilyIndex;
7975     uint32_t                    dstQueueFamilyIndex;
7976     VkBuffer                    buffer;
7977     VkDeviceSize                offset;
7978     VkDeviceSize                size;
7979 } VkBufferMemoryBarrier2KHR;
7980 
7981 typedef struct VkImageMemoryBarrier2KHR {
7982     VkStructureType             sType;
7983     const void*                 pNext;
7984     VkPipelineStageFlags2KHR    srcStageMask;
7985     VkAccessFlags2KHR           srcAccessMask;
7986     VkPipelineStageFlags2KHR    dstStageMask;
7987     VkAccessFlags2KHR           dstAccessMask;
7988     VkImageLayout               oldLayout;
7989     VkImageLayout               newLayout;
7990     uint32_t                    srcQueueFamilyIndex;
7991     uint32_t                    dstQueueFamilyIndex;
7992     VkImage                     image;
7993     VkImageSubresourceRange     subresourceRange;
7994 } VkImageMemoryBarrier2KHR;
7995 
7996 typedef struct VkDependencyInfoKHR {
7997     VkStructureType                     sType;
7998     const void*                         pNext;
7999     VkDependencyFlags                   dependencyFlags;
8000     uint32_t                            memoryBarrierCount;
8001     const VkMemoryBarrier2KHR*          pMemoryBarriers;
8002     uint32_t                            bufferMemoryBarrierCount;
8003     const VkBufferMemoryBarrier2KHR*    pBufferMemoryBarriers;
8004     uint32_t                            imageMemoryBarrierCount;
8005     const VkImageMemoryBarrier2KHR*     pImageMemoryBarriers;
8006 } VkDependencyInfoKHR;
8007 
8008 typedef struct VkSemaphoreSubmitInfoKHR {
8009     VkStructureType             sType;
8010     const void*                 pNext;
8011     VkSemaphore                 semaphore;
8012     uint64_t                    value;
8013     VkPipelineStageFlags2KHR    stageMask;
8014     uint32_t                    deviceIndex;
8015 } VkSemaphoreSubmitInfoKHR;
8016 
8017 typedef struct VkCommandBufferSubmitInfoKHR {
8018     VkStructureType    sType;
8019     const void*        pNext;
8020     VkCommandBuffer    commandBuffer;
8021     uint32_t           deviceMask;
8022 } VkCommandBufferSubmitInfoKHR;
8023 
8024 typedef struct VkSubmitInfo2KHR {
8025     VkStructureType                        sType;
8026     const void*                            pNext;
8027     VkSubmitFlagsKHR                       flags;
8028     uint32_t                               waitSemaphoreInfoCount;
8029     const VkSemaphoreSubmitInfoKHR*        pWaitSemaphoreInfos;
8030     uint32_t                               commandBufferInfoCount;
8031     const VkCommandBufferSubmitInfoKHR*    pCommandBufferInfos;
8032     uint32_t                               signalSemaphoreInfoCount;
8033     const VkSemaphoreSubmitInfoKHR*        pSignalSemaphoreInfos;
8034 } VkSubmitInfo2KHR;
8035 
8036 typedef struct VkPhysicalDeviceSynchronization2FeaturesKHR {
8037     VkStructureType    sType;
8038     void*              pNext;
8039     VkBool32           synchronization2;
8040 } VkPhysicalDeviceSynchronization2FeaturesKHR;
8041 
8042 typedef struct VkQueueFamilyCheckpointProperties2NV {
8043     VkStructureType             sType;
8044     void*                       pNext;
8045     VkPipelineStageFlags2KHR    checkpointExecutionStageMask;
8046 } VkQueueFamilyCheckpointProperties2NV;
8047 
8048 typedef struct VkCheckpointData2NV {
8049     VkStructureType             sType;
8050     void*                       pNext;
8051     VkPipelineStageFlags2KHR    stage;
8052     void*                       pCheckpointMarker;
8053 } VkCheckpointData2NV;
8054 
8055 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer                   commandBuffer, VkEvent                                             event, const VkDependencyInfoKHR*                          pDependencyInfo);
8056 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer                   commandBuffer, VkEvent                                             event, VkPipelineStageFlags2KHR                            stageMask);
8057 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer                   commandBuffer, uint32_t                                            eventCount, const VkEvent*                     pEvents, const VkDependencyInfoKHR*         pDependencyInfos);
8058 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer                   commandBuffer, const VkDependencyInfoKHR*                                pDependencyInfo);
8059 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR                            stage, VkQueryPool                                         queryPool, uint32_t                                            query);
8060 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue                           queue, uint32_t                            submitCount, const VkSubmitInfo2KHR*           pSubmits, VkFence           fence);
8061 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2KHR                            stage, VkBuffer                                            dstBuffer, VkDeviceSize                                        dstOffset, uint32_t                                            marker);
8062 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData);
8063 
8064 #ifndef VK_NO_PROTOTYPES
8065 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(
8066     VkCommandBuffer                             commandBuffer,
8067     VkEvent                                     event,
8068     const VkDependencyInfoKHR*                  pDependencyInfo);
8069 
8070 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(
8071     VkCommandBuffer                             commandBuffer,
8072     VkEvent                                     event,
8073     VkPipelineStageFlags2KHR                    stageMask);
8074 
8075 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(
8076     VkCommandBuffer                             commandBuffer,
8077     uint32_t                                    eventCount,
8078     const VkEvent*                              pEvents,
8079     const VkDependencyInfoKHR*                  pDependencyInfos);
8080 
8081 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(
8082     VkCommandBuffer                             commandBuffer,
8083     const VkDependencyInfoKHR*                  pDependencyInfo);
8084 
8085 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(
8086     VkCommandBuffer                             commandBuffer,
8087     VkPipelineStageFlags2KHR                    stage,
8088     VkQueryPool                                 queryPool,
8089     uint32_t                                    query);
8090 
8091 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(
8092     VkQueue                                     queue,
8093     uint32_t                                    submitCount,
8094     const VkSubmitInfo2KHR*                     pSubmits,
8095     VkFence                                     fence);
8096 
8097 VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(
8098     VkCommandBuffer                             commandBuffer,
8099     VkPipelineStageFlags2KHR                    stage,
8100     VkBuffer                                    dstBuffer,
8101     VkDeviceSize                                dstOffset,
8102     uint32_t                                    marker);
8103 
8104 VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(
8105     VkQueue                                     queue,
8106     uint32_t*                                   pCheckpointDataCount,
8107     VkCheckpointData2NV*                        pCheckpointData);
8108 #endif
8109 
8110 
8111 #define VK_KHR_shader_subgroup_uniform_control_flow 1
8112 #define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1
8113 #define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow"
8114 typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
8115     VkStructureType    sType;
8116     void*              pNext;
8117     VkBool32           shaderSubgroupUniformControlFlow;
8118 } VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
8119 
8120 
8121 
8122 #define VK_KHR_zero_initialize_workgroup_memory 1
8123 #define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION 1
8124 #define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME "VK_KHR_zero_initialize_workgroup_memory"
8125 typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
8126     VkStructureType    sType;
8127     void*              pNext;
8128     VkBool32           shaderZeroInitializeWorkgroupMemory;
8129 } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
8130 
8131 
8132 
8133 #define VK_KHR_workgroup_memory_explicit_layout 1
8134 #define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION 1
8135 #define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME "VK_KHR_workgroup_memory_explicit_layout"
8136 typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
8137     VkStructureType    sType;
8138     void*              pNext;
8139     VkBool32           workgroupMemoryExplicitLayout;
8140     VkBool32           workgroupMemoryExplicitLayoutScalarBlockLayout;
8141     VkBool32           workgroupMemoryExplicitLayout8BitAccess;
8142     VkBool32           workgroupMemoryExplicitLayout16BitAccess;
8143 } VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
8144 
8145 
8146 
8147 #define VK_KHR_copy_commands2 1
8148 #define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1
8149 #define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2"
8150 typedef struct VkBufferCopy2KHR {
8151     VkStructureType    sType;
8152     const void*        pNext;
8153     VkDeviceSize       srcOffset;
8154     VkDeviceSize       dstOffset;
8155     VkDeviceSize       size;
8156 } VkBufferCopy2KHR;
8157 
8158 typedef struct VkCopyBufferInfo2KHR {
8159     VkStructureType            sType;
8160     const void*                pNext;
8161     VkBuffer                   srcBuffer;
8162     VkBuffer                   dstBuffer;
8163     uint32_t                   regionCount;
8164     const VkBufferCopy2KHR*    pRegions;
8165 } VkCopyBufferInfo2KHR;
8166 
8167 typedef struct VkImageCopy2KHR {
8168     VkStructureType             sType;
8169     const void*                 pNext;
8170     VkImageSubresourceLayers    srcSubresource;
8171     VkOffset3D                  srcOffset;
8172     VkImageSubresourceLayers    dstSubresource;
8173     VkOffset3D                  dstOffset;
8174     VkExtent3D                  extent;
8175 } VkImageCopy2KHR;
8176 
8177 typedef struct VkCopyImageInfo2KHR {
8178     VkStructureType           sType;
8179     const void*               pNext;
8180     VkImage                   srcImage;
8181     VkImageLayout             srcImageLayout;
8182     VkImage                   dstImage;
8183     VkImageLayout             dstImageLayout;
8184     uint32_t                  regionCount;
8185     const VkImageCopy2KHR*    pRegions;
8186 } VkCopyImageInfo2KHR;
8187 
8188 typedef struct VkBufferImageCopy2KHR {
8189     VkStructureType             sType;
8190     const void*                 pNext;
8191     VkDeviceSize                bufferOffset;
8192     uint32_t                    bufferRowLength;
8193     uint32_t                    bufferImageHeight;
8194     VkImageSubresourceLayers    imageSubresource;
8195     VkOffset3D                  imageOffset;
8196     VkExtent3D                  imageExtent;
8197 } VkBufferImageCopy2KHR;
8198 
8199 typedef struct VkCopyBufferToImageInfo2KHR {
8200     VkStructureType                 sType;
8201     const void*                     pNext;
8202     VkBuffer                        srcBuffer;
8203     VkImage                         dstImage;
8204     VkImageLayout                   dstImageLayout;
8205     uint32_t                        regionCount;
8206     const VkBufferImageCopy2KHR*    pRegions;
8207 } VkCopyBufferToImageInfo2KHR;
8208 
8209 typedef struct VkCopyImageToBufferInfo2KHR {
8210     VkStructureType                 sType;
8211     const void*                     pNext;
8212     VkImage                         srcImage;
8213     VkImageLayout                   srcImageLayout;
8214     VkBuffer                        dstBuffer;
8215     uint32_t                        regionCount;
8216     const VkBufferImageCopy2KHR*    pRegions;
8217 } VkCopyImageToBufferInfo2KHR;
8218 
8219 typedef struct VkImageBlit2KHR {
8220     VkStructureType             sType;
8221     const void*                 pNext;
8222     VkImageSubresourceLayers    srcSubresource;
8223     VkOffset3D                  srcOffsets[2];
8224     VkImageSubresourceLayers    dstSubresource;
8225     VkOffset3D                  dstOffsets[2];
8226 } VkImageBlit2KHR;
8227 
8228 typedef struct VkBlitImageInfo2KHR {
8229     VkStructureType           sType;
8230     const void*               pNext;
8231     VkImage                   srcImage;
8232     VkImageLayout             srcImageLayout;
8233     VkImage                   dstImage;
8234     VkImageLayout             dstImageLayout;
8235     uint32_t                  regionCount;
8236     const VkImageBlit2KHR*    pRegions;
8237     VkFilter                  filter;
8238 } VkBlitImageInfo2KHR;
8239 
8240 typedef struct VkImageResolve2KHR {
8241     VkStructureType             sType;
8242     const void*                 pNext;
8243     VkImageSubresourceLayers    srcSubresource;
8244     VkOffset3D                  srcOffset;
8245     VkImageSubresourceLayers    dstSubresource;
8246     VkOffset3D                  dstOffset;
8247     VkExtent3D                  extent;
8248 } VkImageResolve2KHR;
8249 
8250 typedef struct VkResolveImageInfo2KHR {
8251     VkStructureType              sType;
8252     const void*                  pNext;
8253     VkImage                      srcImage;
8254     VkImageLayout                srcImageLayout;
8255     VkImage                      dstImage;
8256     VkImageLayout                dstImageLayout;
8257     uint32_t                     regionCount;
8258     const VkImageResolve2KHR*    pRegions;
8259 } VkResolveImageInfo2KHR;
8260 
8261 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo);
8262 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo);
8263 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo);
8264 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo);
8265 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo);
8266 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo);
8267 
8268 #ifndef VK_NO_PROTOTYPES
8269 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(
8270     VkCommandBuffer                             commandBuffer,
8271     const VkCopyBufferInfo2KHR*                 pCopyBufferInfo);
8272 
8273 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(
8274     VkCommandBuffer                             commandBuffer,
8275     const VkCopyImageInfo2KHR*                  pCopyImageInfo);
8276 
8277 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(
8278     VkCommandBuffer                             commandBuffer,
8279     const VkCopyBufferToImageInfo2KHR*          pCopyBufferToImageInfo);
8280 
8281 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(
8282     VkCommandBuffer                             commandBuffer,
8283     const VkCopyImageToBufferInfo2KHR*          pCopyImageToBufferInfo);
8284 
8285 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(
8286     VkCommandBuffer                             commandBuffer,
8287     const VkBlitImageInfo2KHR*                  pBlitImageInfo);
8288 
8289 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(
8290     VkCommandBuffer                             commandBuffer,
8291     const VkResolveImageInfo2KHR*               pResolveImageInfo);
8292 #endif
8293 
8294 
8295 #define VK_EXT_debug_report 1
8296 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
8297 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION  10
8298 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
8299 
8300 typedef enum VkDebugReportObjectTypeEXT {
8301     VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
8302     VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
8303     VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
8304     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
8305     VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
8306     VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
8307     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
8308     VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
8309     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
8310     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
8311     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
8312     VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
8313     VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
8314     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
8315     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
8316     VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
8317     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
8318     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
8319     VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
8320     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
8321     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
8322     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
8323     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
8324     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
8325     VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
8326     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
8327     VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
8328     VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
8329     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
8330     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
8331     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
8332     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,
8333     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,
8334     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000,
8335     VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000,
8336     VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001,
8337     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000,
8338     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,
8339     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
8340     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
8341     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
8342     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
8343     VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
8344 } VkDebugReportObjectTypeEXT;
8345 
8346 typedef enum VkDebugReportFlagBitsEXT {
8347     VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
8348     VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
8349     VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
8350     VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
8351     VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
8352     VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
8353 } VkDebugReportFlagBitsEXT;
8354 typedef VkFlags VkDebugReportFlagsEXT;
8355 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
8356     VkDebugReportFlagsEXT                       flags,
8357     VkDebugReportObjectTypeEXT                  objectType,
8358     uint64_t                                    object,
8359     size_t                                      location,
8360     int32_t                                     messageCode,
8361     const char*                                 pLayerPrefix,
8362     const char*                                 pMessage,
8363     void*                                       pUserData);
8364 
8365 typedef struct VkDebugReportCallbackCreateInfoEXT {
8366     VkStructureType                 sType;
8367     const void*                     pNext;
8368     VkDebugReportFlagsEXT           flags;
8369     PFN_vkDebugReportCallbackEXT    pfnCallback;
8370     void*                           pUserData;
8371 } VkDebugReportCallbackCreateInfoEXT;
8372 
8373 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
8374 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
8375 typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
8376 
8377 #ifndef VK_NO_PROTOTYPES
8378 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
8379     VkInstance                                  instance,
8380     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
8381     const VkAllocationCallbacks*                pAllocator,
8382     VkDebugReportCallbackEXT*                   pCallback);
8383 
8384 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
8385     VkInstance                                  instance,
8386     VkDebugReportCallbackEXT                    callback,
8387     const VkAllocationCallbacks*                pAllocator);
8388 
8389 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
8390     VkInstance                                  instance,
8391     VkDebugReportFlagsEXT                       flags,
8392     VkDebugReportObjectTypeEXT                  objectType,
8393     uint64_t                                    object,
8394     size_t                                      location,
8395     int32_t                                     messageCode,
8396     const char*                                 pLayerPrefix,
8397     const char*                                 pMessage);
8398 #endif
8399 
8400 
8401 #define VK_NV_glsl_shader 1
8402 #define VK_NV_GLSL_SHADER_SPEC_VERSION    1
8403 #define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
8404 
8405 
8406 #define VK_EXT_depth_range_unrestricted 1
8407 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
8408 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
8409 
8410 
8411 #define VK_IMG_filter_cubic 1
8412 #define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
8413 #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
8414 
8415 
8416 #define VK_AMD_rasterization_order 1
8417 #define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
8418 #define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
8419 
8420 typedef enum VkRasterizationOrderAMD {
8421     VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
8422     VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
8423     VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
8424 } VkRasterizationOrderAMD;
8425 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
8426     VkStructureType            sType;
8427     const void*                pNext;
8428     VkRasterizationOrderAMD    rasterizationOrder;
8429 } VkPipelineRasterizationStateRasterizationOrderAMD;
8430 
8431 
8432 
8433 #define VK_AMD_shader_trinary_minmax 1
8434 #define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
8435 #define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
8436 
8437 
8438 #define VK_AMD_shader_explicit_vertex_parameter 1
8439 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
8440 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
8441 
8442 
8443 #define VK_EXT_debug_marker 1
8444 #define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
8445 #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
8446 typedef struct VkDebugMarkerObjectNameInfoEXT {
8447     VkStructureType               sType;
8448     const void*                   pNext;
8449     VkDebugReportObjectTypeEXT    objectType;
8450     uint64_t                      object;
8451     const char*                   pObjectName;
8452 } VkDebugMarkerObjectNameInfoEXT;
8453 
8454 typedef struct VkDebugMarkerObjectTagInfoEXT {
8455     VkStructureType               sType;
8456     const void*                   pNext;
8457     VkDebugReportObjectTypeEXT    objectType;
8458     uint64_t                      object;
8459     uint64_t                      tagName;
8460     size_t                        tagSize;
8461     const void*                   pTag;
8462 } VkDebugMarkerObjectTagInfoEXT;
8463 
8464 typedef struct VkDebugMarkerMarkerInfoEXT {
8465     VkStructureType    sType;
8466     const void*        pNext;
8467     const char*        pMarkerName;
8468     float              color[4];
8469 } VkDebugMarkerMarkerInfoEXT;
8470 
8471 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
8472 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
8473 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
8474 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
8475 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
8476 
8477 #ifndef VK_NO_PROTOTYPES
8478 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
8479     VkDevice                                    device,
8480     const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
8481 
8482 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
8483     VkDevice                                    device,
8484     const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
8485 
8486 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
8487     VkCommandBuffer                             commandBuffer,
8488     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
8489 
8490 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
8491     VkCommandBuffer                             commandBuffer);
8492 
8493 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
8494     VkCommandBuffer                             commandBuffer,
8495     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
8496 #endif
8497 
8498 
8499 #define VK_AMD_gcn_shader 1
8500 #define VK_AMD_GCN_SHADER_SPEC_VERSION    1
8501 #define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
8502 
8503 
8504 #define VK_NV_dedicated_allocation 1
8505 #define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
8506 #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
8507 typedef struct VkDedicatedAllocationImageCreateInfoNV {
8508     VkStructureType    sType;
8509     const void*        pNext;
8510     VkBool32           dedicatedAllocation;
8511 } VkDedicatedAllocationImageCreateInfoNV;
8512 
8513 typedef struct VkDedicatedAllocationBufferCreateInfoNV {
8514     VkStructureType    sType;
8515     const void*        pNext;
8516     VkBool32           dedicatedAllocation;
8517 } VkDedicatedAllocationBufferCreateInfoNV;
8518 
8519 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
8520     VkStructureType    sType;
8521     const void*        pNext;
8522     VkImage            image;
8523     VkBuffer           buffer;
8524 } VkDedicatedAllocationMemoryAllocateInfoNV;
8525 
8526 
8527 
8528 #define VK_EXT_transform_feedback 1
8529 #define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1
8530 #define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback"
8531 typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT;
8532 typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
8533     VkStructureType    sType;
8534     void*              pNext;
8535     VkBool32           transformFeedback;
8536     VkBool32           geometryStreams;
8537 } VkPhysicalDeviceTransformFeedbackFeaturesEXT;
8538 
8539 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
8540     VkStructureType    sType;
8541     void*              pNext;
8542     uint32_t           maxTransformFeedbackStreams;
8543     uint32_t           maxTransformFeedbackBuffers;
8544     VkDeviceSize       maxTransformFeedbackBufferSize;
8545     uint32_t           maxTransformFeedbackStreamDataSize;
8546     uint32_t           maxTransformFeedbackBufferDataSize;
8547     uint32_t           maxTransformFeedbackBufferDataStride;
8548     VkBool32           transformFeedbackQueries;
8549     VkBool32           transformFeedbackStreamsLinesTriangles;
8550     VkBool32           transformFeedbackRasterizationStreamSelect;
8551     VkBool32           transformFeedbackDraw;
8552 } VkPhysicalDeviceTransformFeedbackPropertiesEXT;
8553 
8554 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT {
8555     VkStructureType                                     sType;
8556     const void*                                         pNext;
8557     VkPipelineRasterizationStateStreamCreateFlagsEXT    flags;
8558     uint32_t                                            rasterizationStream;
8559 } VkPipelineRasterizationStateStreamCreateInfoEXT;
8560 
8561 typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);
8562 typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
8563 typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
8564 typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index);
8565 typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
8566 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride);
8567 
8568 #ifndef VK_NO_PROTOTYPES
8569 VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(
8570     VkCommandBuffer                             commandBuffer,
8571     uint32_t                                    firstBinding,
8572     uint32_t                                    bindingCount,
8573     const VkBuffer*                             pBuffers,
8574     const VkDeviceSize*                         pOffsets,
8575     const VkDeviceSize*                         pSizes);
8576 
8577 VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(
8578     VkCommandBuffer                             commandBuffer,
8579     uint32_t                                    firstCounterBuffer,
8580     uint32_t                                    counterBufferCount,
8581     const VkBuffer*                             pCounterBuffers,
8582     const VkDeviceSize*                         pCounterBufferOffsets);
8583 
8584 VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(
8585     VkCommandBuffer                             commandBuffer,
8586     uint32_t                                    firstCounterBuffer,
8587     uint32_t                                    counterBufferCount,
8588     const VkBuffer*                             pCounterBuffers,
8589     const VkDeviceSize*                         pCounterBufferOffsets);
8590 
8591 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(
8592     VkCommandBuffer                             commandBuffer,
8593     VkQueryPool                                 queryPool,
8594     uint32_t                                    query,
8595     VkQueryControlFlags                         flags,
8596     uint32_t                                    index);
8597 
8598 VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(
8599     VkCommandBuffer                             commandBuffer,
8600     VkQueryPool                                 queryPool,
8601     uint32_t                                    query,
8602     uint32_t                                    index);
8603 
8604 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(
8605     VkCommandBuffer                             commandBuffer,
8606     uint32_t                                    instanceCount,
8607     uint32_t                                    firstInstance,
8608     VkBuffer                                    counterBuffer,
8609     VkDeviceSize                                counterBufferOffset,
8610     uint32_t                                    counterOffset,
8611     uint32_t                                    vertexStride);
8612 #endif
8613 
8614 
8615 #define VK_NVX_binary_import 1
8616 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX)
8617 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX)
8618 #define VK_NVX_BINARY_IMPORT_SPEC_VERSION 1
8619 #define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import"
8620 typedef struct VkCuModuleCreateInfoNVX {
8621     VkStructureType    sType;
8622     const void*        pNext;
8623     size_t             dataSize;
8624     const void*        pData;
8625 } VkCuModuleCreateInfoNVX;
8626 
8627 typedef struct VkCuFunctionCreateInfoNVX {
8628     VkStructureType    sType;
8629     const void*        pNext;
8630     VkCuModuleNVX      module;
8631     const char*        pName;
8632 } VkCuFunctionCreateInfoNVX;
8633 
8634 typedef struct VkCuLaunchInfoNVX {
8635     VkStructureType        sType;
8636     const void*            pNext;
8637     VkCuFunctionNVX        function;
8638     uint32_t               gridDimX;
8639     uint32_t               gridDimY;
8640     uint32_t               gridDimZ;
8641     uint32_t               blockDimX;
8642     uint32_t               blockDimY;
8643     uint32_t               blockDimZ;
8644     uint32_t               sharedMemBytes;
8645     size_t                 paramCount;
8646     const void* const *    pParams;
8647     size_t                 extraCount;
8648     const void* const *    pExtras;
8649 } VkCuLaunchInfoNVX;
8650 
8651 typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule);
8652 typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction);
8653 typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator);
8654 typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator);
8655 typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo);
8656 
8657 #ifndef VK_NO_PROTOTYPES
8658 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(
8659     VkDevice                                    device,
8660     const VkCuModuleCreateInfoNVX*              pCreateInfo,
8661     const VkAllocationCallbacks*                pAllocator,
8662     VkCuModuleNVX*                              pModule);
8663 
8664 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(
8665     VkDevice                                    device,
8666     const VkCuFunctionCreateInfoNVX*            pCreateInfo,
8667     const VkAllocationCallbacks*                pAllocator,
8668     VkCuFunctionNVX*                            pFunction);
8669 
8670 VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(
8671     VkDevice                                    device,
8672     VkCuModuleNVX                               module,
8673     const VkAllocationCallbacks*                pAllocator);
8674 
8675 VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(
8676     VkDevice                                    device,
8677     VkCuFunctionNVX                             function,
8678     const VkAllocationCallbacks*                pAllocator);
8679 
8680 VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(
8681     VkCommandBuffer                             commandBuffer,
8682     const VkCuLaunchInfoNVX*                    pLaunchInfo);
8683 #endif
8684 
8685 
8686 #define VK_NVX_image_view_handle 1
8687 #define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 2
8688 #define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle"
8689 typedef struct VkImageViewHandleInfoNVX {
8690     VkStructureType     sType;
8691     const void*         pNext;
8692     VkImageView         imageView;
8693     VkDescriptorType    descriptorType;
8694     VkSampler           sampler;
8695 } VkImageViewHandleInfoNVX;
8696 
8697 typedef struct VkImageViewAddressPropertiesNVX {
8698     VkStructureType    sType;
8699     void*              pNext;
8700     VkDeviceAddress    deviceAddress;
8701     VkDeviceSize       size;
8702 } VkImageViewAddressPropertiesNVX;
8703 
8704 typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
8705 typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties);
8706 
8707 #ifndef VK_NO_PROTOTYPES
8708 VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(
8709     VkDevice                                    device,
8710     const VkImageViewHandleInfoNVX*             pInfo);
8711 
8712 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(
8713     VkDevice                                    device,
8714     VkImageView                                 imageView,
8715     VkImageViewAddressPropertiesNVX*            pProperties);
8716 #endif
8717 
8718 
8719 #define VK_AMD_draw_indirect_count 1
8720 #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2
8721 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
8722 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
8723 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
8724 
8725 #ifndef VK_NO_PROTOTYPES
8726 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
8727     VkCommandBuffer                             commandBuffer,
8728     VkBuffer                                    buffer,
8729     VkDeviceSize                                offset,
8730     VkBuffer                                    countBuffer,
8731     VkDeviceSize                                countBufferOffset,
8732     uint32_t                                    maxDrawCount,
8733     uint32_t                                    stride);
8734 
8735 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
8736     VkCommandBuffer                             commandBuffer,
8737     VkBuffer                                    buffer,
8738     VkDeviceSize                                offset,
8739     VkBuffer                                    countBuffer,
8740     VkDeviceSize                                countBufferOffset,
8741     uint32_t                                    maxDrawCount,
8742     uint32_t                                    stride);
8743 #endif
8744 
8745 
8746 #define VK_AMD_negative_viewport_height 1
8747 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
8748 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
8749 
8750 
8751 #define VK_AMD_gpu_shader_half_float 1
8752 #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2
8753 #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
8754 
8755 
8756 #define VK_AMD_shader_ballot 1
8757 #define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
8758 #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
8759 
8760 
8761 #define VK_AMD_texture_gather_bias_lod 1
8762 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
8763 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
8764 typedef struct VkTextureLODGatherFormatPropertiesAMD {
8765     VkStructureType    sType;
8766     void*              pNext;
8767     VkBool32           supportsTextureGatherLODBiasAMD;
8768 } VkTextureLODGatherFormatPropertiesAMD;
8769 
8770 
8771 
8772 #define VK_AMD_shader_info 1
8773 #define VK_AMD_SHADER_INFO_SPEC_VERSION   1
8774 #define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"
8775 
8776 typedef enum VkShaderInfoTypeAMD {
8777     VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,
8778     VK_SHADER_INFO_TYPE_BINARY_AMD = 1,
8779     VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
8780     VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF
8781 } VkShaderInfoTypeAMD;
8782 typedef struct VkShaderResourceUsageAMD {
8783     uint32_t    numUsedVgprs;
8784     uint32_t    numUsedSgprs;
8785     uint32_t    ldsSizePerLocalWorkGroup;
8786     size_t      ldsUsageSizeInBytes;
8787     size_t      scratchMemUsageInBytes;
8788 } VkShaderResourceUsageAMD;
8789 
8790 typedef struct VkShaderStatisticsInfoAMD {
8791     VkShaderStageFlags          shaderStageMask;
8792     VkShaderResourceUsageAMD    resourceUsage;
8793     uint32_t                    numPhysicalVgprs;
8794     uint32_t                    numPhysicalSgprs;
8795     uint32_t                    numAvailableVgprs;
8796     uint32_t                    numAvailableSgprs;
8797     uint32_t                    computeWorkGroupSize[3];
8798 } VkShaderStatisticsInfoAMD;
8799 
8800 typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);
8801 
8802 #ifndef VK_NO_PROTOTYPES
8803 VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(
8804     VkDevice                                    device,
8805     VkPipeline                                  pipeline,
8806     VkShaderStageFlagBits                       shaderStage,
8807     VkShaderInfoTypeAMD                         infoType,
8808     size_t*                                     pInfoSize,
8809     void*                                       pInfo);
8810 #endif
8811 
8812 
8813 #define VK_AMD_shader_image_load_store_lod 1
8814 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
8815 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"
8816 
8817 
8818 #define VK_NV_corner_sampled_image 1
8819 #define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2
8820 #define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"
8821 typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
8822     VkStructureType    sType;
8823     void*              pNext;
8824     VkBool32           cornerSampledImage;
8825 } VkPhysicalDeviceCornerSampledImageFeaturesNV;
8826 
8827 
8828 
8829 #define VK_IMG_format_pvrtc 1
8830 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
8831 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
8832 
8833 
8834 #define VK_NV_external_memory_capabilities 1
8835 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
8836 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
8837 
8838 typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
8839     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
8840     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
8841     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
8842     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
8843     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8844 } VkExternalMemoryHandleTypeFlagBitsNV;
8845 typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
8846 
8847 typedef enum VkExternalMemoryFeatureFlagBitsNV {
8848     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
8849     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
8850     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
8851     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8852 } VkExternalMemoryFeatureFlagBitsNV;
8853 typedef VkFlags VkExternalMemoryFeatureFlagsNV;
8854 typedef struct VkExternalImageFormatPropertiesNV {
8855     VkImageFormatProperties              imageFormatProperties;
8856     VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
8857     VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
8858     VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
8859 } VkExternalImageFormatPropertiesNV;
8860 
8861 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
8862 
8863 #ifndef VK_NO_PROTOTYPES
8864 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
8865     VkPhysicalDevice                            physicalDevice,
8866     VkFormat                                    format,
8867     VkImageType                                 type,
8868     VkImageTiling                               tiling,
8869     VkImageUsageFlags                           usage,
8870     VkImageCreateFlags                          flags,
8871     VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
8872     VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
8873 #endif
8874 
8875 
8876 #define VK_NV_external_memory 1
8877 #define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
8878 #define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
8879 typedef struct VkExternalMemoryImageCreateInfoNV {
8880     VkStructureType                      sType;
8881     const void*                          pNext;
8882     VkExternalMemoryHandleTypeFlagsNV    handleTypes;
8883 } VkExternalMemoryImageCreateInfoNV;
8884 
8885 typedef struct VkExportMemoryAllocateInfoNV {
8886     VkStructureType                      sType;
8887     const void*                          pNext;
8888     VkExternalMemoryHandleTypeFlagsNV    handleTypes;
8889 } VkExportMemoryAllocateInfoNV;
8890 
8891 
8892 
8893 #define VK_EXT_validation_flags 1
8894 #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2
8895 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
8896 
8897 typedef enum VkValidationCheckEXT {
8898     VK_VALIDATION_CHECK_ALL_EXT = 0,
8899     VK_VALIDATION_CHECK_SHADERS_EXT = 1,
8900     VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
8901 } VkValidationCheckEXT;
8902 typedef struct VkValidationFlagsEXT {
8903     VkStructureType                sType;
8904     const void*                    pNext;
8905     uint32_t                       disabledValidationCheckCount;
8906     const VkValidationCheckEXT*    pDisabledValidationChecks;
8907 } VkValidationFlagsEXT;
8908 
8909 
8910 
8911 #define VK_EXT_shader_subgroup_ballot 1
8912 #define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
8913 #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
8914 
8915 
8916 #define VK_EXT_shader_subgroup_vote 1
8917 #define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
8918 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
8919 
8920 
8921 #define VK_EXT_texture_compression_astc_hdr 1
8922 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1
8923 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
8924 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
8925     VkStructureType    sType;
8926     void*              pNext;
8927     VkBool32           textureCompressionASTC_HDR;
8928 } VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
8929 
8930 
8931 
8932 #define VK_EXT_astc_decode_mode 1
8933 #define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
8934 #define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"
8935 typedef struct VkImageViewASTCDecodeModeEXT {
8936     VkStructureType    sType;
8937     const void*        pNext;
8938     VkFormat           decodeMode;
8939 } VkImageViewASTCDecodeModeEXT;
8940 
8941 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
8942     VkStructureType    sType;
8943     void*              pNext;
8944     VkBool32           decodeModeSharedExponent;
8945 } VkPhysicalDeviceASTCDecodeFeaturesEXT;
8946 
8947 
8948 
8949 #define VK_EXT_conditional_rendering 1
8950 #define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2
8951 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
8952 
8953 typedef enum VkConditionalRenderingFlagBitsEXT {
8954     VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
8955     VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
8956 } VkConditionalRenderingFlagBitsEXT;
8957 typedef VkFlags VkConditionalRenderingFlagsEXT;
8958 typedef struct VkConditionalRenderingBeginInfoEXT {
8959     VkStructureType                   sType;
8960     const void*                       pNext;
8961     VkBuffer                          buffer;
8962     VkDeviceSize                      offset;
8963     VkConditionalRenderingFlagsEXT    flags;
8964 } VkConditionalRenderingBeginInfoEXT;
8965 
8966 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
8967     VkStructureType    sType;
8968     void*              pNext;
8969     VkBool32           conditionalRendering;
8970     VkBool32           inheritedConditionalRendering;
8971 } VkPhysicalDeviceConditionalRenderingFeaturesEXT;
8972 
8973 typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
8974     VkStructureType    sType;
8975     const void*        pNext;
8976     VkBool32           conditionalRenderingEnable;
8977 } VkCommandBufferInheritanceConditionalRenderingInfoEXT;
8978 
8979 typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
8980 typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer);
8981 
8982 #ifndef VK_NO_PROTOTYPES
8983 VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(
8984     VkCommandBuffer                             commandBuffer,
8985     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
8986 
8987 VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(
8988     VkCommandBuffer                             commandBuffer);
8989 #endif
8990 
8991 
8992 #define VK_NV_clip_space_w_scaling 1
8993 #define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
8994 #define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
8995 typedef struct VkViewportWScalingNV {
8996     float    xcoeff;
8997     float    ycoeff;
8998 } VkViewportWScalingNV;
8999 
9000 typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
9001     VkStructureType                sType;
9002     const void*                    pNext;
9003     VkBool32                       viewportWScalingEnable;
9004     uint32_t                       viewportCount;
9005     const VkViewportWScalingNV*    pViewportWScalings;
9006 } VkPipelineViewportWScalingStateCreateInfoNV;
9007 
9008 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
9009 
9010 #ifndef VK_NO_PROTOTYPES
9011 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
9012     VkCommandBuffer                             commandBuffer,
9013     uint32_t                                    firstViewport,
9014     uint32_t                                    viewportCount,
9015     const VkViewportWScalingNV*                 pViewportWScalings);
9016 #endif
9017 
9018 
9019 #define VK_EXT_direct_mode_display 1
9020 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
9021 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
9022 typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
9023 
9024 #ifndef VK_NO_PROTOTYPES
9025 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
9026     VkPhysicalDevice                            physicalDevice,
9027     VkDisplayKHR                                display);
9028 #endif
9029 
9030 
9031 #define VK_EXT_display_surface_counter 1
9032 #define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
9033 #define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
9034 
9035 typedef enum VkSurfaceCounterFlagBitsEXT {
9036     VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001,
9037     VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT,
9038     VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
9039 } VkSurfaceCounterFlagBitsEXT;
9040 typedef VkFlags VkSurfaceCounterFlagsEXT;
9041 typedef struct VkSurfaceCapabilities2EXT {
9042     VkStructureType                  sType;
9043     void*                            pNext;
9044     uint32_t                         minImageCount;
9045     uint32_t                         maxImageCount;
9046     VkExtent2D                       currentExtent;
9047     VkExtent2D                       minImageExtent;
9048     VkExtent2D                       maxImageExtent;
9049     uint32_t                         maxImageArrayLayers;
9050     VkSurfaceTransformFlagsKHR       supportedTransforms;
9051     VkSurfaceTransformFlagBitsKHR    currentTransform;
9052     VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
9053     VkImageUsageFlags                supportedUsageFlags;
9054     VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
9055 } VkSurfaceCapabilities2EXT;
9056 
9057 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
9058 
9059 #ifndef VK_NO_PROTOTYPES
9060 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
9061     VkPhysicalDevice                            physicalDevice,
9062     VkSurfaceKHR                                surface,
9063     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
9064 #endif
9065 
9066 
9067 #define VK_EXT_display_control 1
9068 #define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
9069 #define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
9070 
9071 typedef enum VkDisplayPowerStateEXT {
9072     VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
9073     VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
9074     VK_DISPLAY_POWER_STATE_ON_EXT = 2,
9075     VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
9076 } VkDisplayPowerStateEXT;
9077 
9078 typedef enum VkDeviceEventTypeEXT {
9079     VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
9080     VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
9081 } VkDeviceEventTypeEXT;
9082 
9083 typedef enum VkDisplayEventTypeEXT {
9084     VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
9085     VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
9086 } VkDisplayEventTypeEXT;
9087 typedef struct VkDisplayPowerInfoEXT {
9088     VkStructureType           sType;
9089     const void*               pNext;
9090     VkDisplayPowerStateEXT    powerState;
9091 } VkDisplayPowerInfoEXT;
9092 
9093 typedef struct VkDeviceEventInfoEXT {
9094     VkStructureType         sType;
9095     const void*             pNext;
9096     VkDeviceEventTypeEXT    deviceEvent;
9097 } VkDeviceEventInfoEXT;
9098 
9099 typedef struct VkDisplayEventInfoEXT {
9100     VkStructureType          sType;
9101     const void*              pNext;
9102     VkDisplayEventTypeEXT    displayEvent;
9103 } VkDisplayEventInfoEXT;
9104 
9105 typedef struct VkSwapchainCounterCreateInfoEXT {
9106     VkStructureType             sType;
9107     const void*                 pNext;
9108     VkSurfaceCounterFlagsEXT    surfaceCounters;
9109 } VkSwapchainCounterCreateInfoEXT;
9110 
9111 typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
9112 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
9113 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
9114 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
9115 
9116 #ifndef VK_NO_PROTOTYPES
9117 VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
9118     VkDevice                                    device,
9119     VkDisplayKHR                                display,
9120     const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
9121 
9122 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
9123     VkDevice                                    device,
9124     const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
9125     const VkAllocationCallbacks*                pAllocator,
9126     VkFence*                                    pFence);
9127 
9128 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
9129     VkDevice                                    device,
9130     VkDisplayKHR                                display,
9131     const VkDisplayEventInfoEXT*                pDisplayEventInfo,
9132     const VkAllocationCallbacks*                pAllocator,
9133     VkFence*                                    pFence);
9134 
9135 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
9136     VkDevice                                    device,
9137     VkSwapchainKHR                              swapchain,
9138     VkSurfaceCounterFlagBitsEXT                 counter,
9139     uint64_t*                                   pCounterValue);
9140 #endif
9141 
9142 
9143 #define VK_GOOGLE_display_timing 1
9144 #define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
9145 #define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
9146 typedef struct VkRefreshCycleDurationGOOGLE {
9147     uint64_t    refreshDuration;
9148 } VkRefreshCycleDurationGOOGLE;
9149 
9150 typedef struct VkPastPresentationTimingGOOGLE {
9151     uint32_t    presentID;
9152     uint64_t    desiredPresentTime;
9153     uint64_t    actualPresentTime;
9154     uint64_t    earliestPresentTime;
9155     uint64_t    presentMargin;
9156 } VkPastPresentationTimingGOOGLE;
9157 
9158 typedef struct VkPresentTimeGOOGLE {
9159     uint32_t    presentID;
9160     uint64_t    desiredPresentTime;
9161 } VkPresentTimeGOOGLE;
9162 
9163 typedef struct VkPresentTimesInfoGOOGLE {
9164     VkStructureType               sType;
9165     const void*                   pNext;
9166     uint32_t                      swapchainCount;
9167     const VkPresentTimeGOOGLE*    pTimes;
9168 } VkPresentTimesInfoGOOGLE;
9169 
9170 typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
9171 typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
9172 
9173 #ifndef VK_NO_PROTOTYPES
9174 VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
9175     VkDevice                                    device,
9176     VkSwapchainKHR                              swapchain,
9177     VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
9178 
9179 VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
9180     VkDevice                                    device,
9181     VkSwapchainKHR                              swapchain,
9182     uint32_t*                                   pPresentationTimingCount,
9183     VkPastPresentationTimingGOOGLE*             pPresentationTimings);
9184 #endif
9185 
9186 
9187 #define VK_NV_sample_mask_override_coverage 1
9188 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
9189 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
9190 
9191 
9192 #define VK_NV_geometry_shader_passthrough 1
9193 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
9194 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
9195 
9196 
9197 #define VK_NV_viewport_array2 1
9198 #define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
9199 #define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
9200 
9201 
9202 #define VK_NVX_multiview_per_view_attributes 1
9203 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
9204 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
9205 typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
9206     VkStructureType    sType;
9207     void*              pNext;
9208     VkBool32           perViewPositionAllComponents;
9209 } VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
9210 
9211 
9212 
9213 #define VK_NV_viewport_swizzle 1
9214 #define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
9215 #define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
9216 
9217 typedef enum VkViewportCoordinateSwizzleNV {
9218     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
9219     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
9220     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
9221     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
9222     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
9223     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
9224     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
9225     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
9226     VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
9227 } VkViewportCoordinateSwizzleNV;
9228 typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
9229 typedef struct VkViewportSwizzleNV {
9230     VkViewportCoordinateSwizzleNV    x;
9231     VkViewportCoordinateSwizzleNV    y;
9232     VkViewportCoordinateSwizzleNV    z;
9233     VkViewportCoordinateSwizzleNV    w;
9234 } VkViewportSwizzleNV;
9235 
9236 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
9237     VkStructureType                                sType;
9238     const void*                                    pNext;
9239     VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
9240     uint32_t                                       viewportCount;
9241     const VkViewportSwizzleNV*                     pViewportSwizzles;
9242 } VkPipelineViewportSwizzleStateCreateInfoNV;
9243 
9244 
9245 
9246 #define VK_EXT_discard_rectangles 1
9247 #define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
9248 #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
9249 
9250 typedef enum VkDiscardRectangleModeEXT {
9251     VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
9252     VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
9253     VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
9254 } VkDiscardRectangleModeEXT;
9255 typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
9256 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
9257     VkStructureType    sType;
9258     void*              pNext;
9259     uint32_t           maxDiscardRectangles;
9260 } VkPhysicalDeviceDiscardRectanglePropertiesEXT;
9261 
9262 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
9263     VkStructureType                                  sType;
9264     const void*                                      pNext;
9265     VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
9266     VkDiscardRectangleModeEXT                        discardRectangleMode;
9267     uint32_t                                         discardRectangleCount;
9268     const VkRect2D*                                  pDiscardRectangles;
9269 } VkPipelineDiscardRectangleStateCreateInfoEXT;
9270 
9271 typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
9272 
9273 #ifndef VK_NO_PROTOTYPES
9274 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
9275     VkCommandBuffer                             commandBuffer,
9276     uint32_t                                    firstDiscardRectangle,
9277     uint32_t                                    discardRectangleCount,
9278     const VkRect2D*                             pDiscardRectangles);
9279 #endif
9280 
9281 
9282 #define VK_EXT_conservative_rasterization 1
9283 #define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
9284 #define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"
9285 
9286 typedef enum VkConservativeRasterizationModeEXT {
9287     VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,
9288     VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,
9289     VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,
9290     VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
9291 } VkConservativeRasterizationModeEXT;
9292 typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;
9293 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
9294     VkStructureType    sType;
9295     void*              pNext;
9296     float              primitiveOverestimationSize;
9297     float              maxExtraPrimitiveOverestimationSize;
9298     float              extraPrimitiveOverestimationSizeGranularity;
9299     VkBool32           primitiveUnderestimation;
9300     VkBool32           conservativePointAndLineRasterization;
9301     VkBool32           degenerateTrianglesRasterized;
9302     VkBool32           degenerateLinesRasterized;
9303     VkBool32           fullyCoveredFragmentShaderInputVariable;
9304     VkBool32           conservativeRasterizationPostDepthCoverage;
9305 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
9306 
9307 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
9308     VkStructureType                                           sType;
9309     const void*                                               pNext;
9310     VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags;
9311     VkConservativeRasterizationModeEXT                        conservativeRasterizationMode;
9312     float                                                     extraPrimitiveOverestimationSize;
9313 } VkPipelineRasterizationConservativeStateCreateInfoEXT;
9314 
9315 
9316 
9317 #define VK_EXT_depth_clip_enable 1
9318 #define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1
9319 #define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable"
9320 typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT;
9321 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
9322     VkStructureType    sType;
9323     void*              pNext;
9324     VkBool32           depthClipEnable;
9325 } VkPhysicalDeviceDepthClipEnableFeaturesEXT;
9326 
9327 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
9328     VkStructureType                                        sType;
9329     const void*                                            pNext;
9330     VkPipelineRasterizationDepthClipStateCreateFlagsEXT    flags;
9331     VkBool32                                               depthClipEnable;
9332 } VkPipelineRasterizationDepthClipStateCreateInfoEXT;
9333 
9334 
9335 
9336 #define VK_EXT_swapchain_colorspace 1
9337 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4
9338 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
9339 
9340 
9341 #define VK_EXT_hdr_metadata 1
9342 #define VK_EXT_HDR_METADATA_SPEC_VERSION  2
9343 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
9344 typedef struct VkXYColorEXT {
9345     float    x;
9346     float    y;
9347 } VkXYColorEXT;
9348 
9349 typedef struct VkHdrMetadataEXT {
9350     VkStructureType    sType;
9351     const void*        pNext;
9352     VkXYColorEXT       displayPrimaryRed;
9353     VkXYColorEXT       displayPrimaryGreen;
9354     VkXYColorEXT       displayPrimaryBlue;
9355     VkXYColorEXT       whitePoint;
9356     float              maxLuminance;
9357     float              minLuminance;
9358     float              maxContentLightLevel;
9359     float              maxFrameAverageLightLevel;
9360 } VkHdrMetadataEXT;
9361 
9362 typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
9363 
9364 #ifndef VK_NO_PROTOTYPES
9365 VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
9366     VkDevice                                    device,
9367     uint32_t                                    swapchainCount,
9368     const VkSwapchainKHR*                       pSwapchains,
9369     const VkHdrMetadataEXT*                     pMetadata);
9370 #endif
9371 
9372 
9373 #define VK_EXT_external_memory_dma_buf 1
9374 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
9375 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"
9376 
9377 
9378 #define VK_EXT_queue_family_foreign 1
9379 #define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
9380 #define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"
9381 #define VK_QUEUE_FAMILY_FOREIGN_EXT       (~2U)
9382 
9383 
9384 #define VK_EXT_debug_utils 1
9385 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)
9386 #define VK_EXT_DEBUG_UTILS_SPEC_VERSION   2
9387 #define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"
9388 typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT;
9389 
9390 typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT {
9391     VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,
9392     VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010,
9393     VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,
9394     VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000,
9395     VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
9396 } VkDebugUtilsMessageSeverityFlagBitsEXT;
9397 
9398 typedef enum VkDebugUtilsMessageTypeFlagBitsEXT {
9399     VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001,
9400     VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002,
9401     VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
9402     VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
9403 } VkDebugUtilsMessageTypeFlagBitsEXT;
9404 typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;
9405 typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;
9406 typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT;
9407 typedef struct VkDebugUtilsLabelEXT {
9408     VkStructureType    sType;
9409     const void*        pNext;
9410     const char*        pLabelName;
9411     float              color[4];
9412 } VkDebugUtilsLabelEXT;
9413 
9414 typedef struct VkDebugUtilsObjectNameInfoEXT {
9415     VkStructureType    sType;
9416     const void*        pNext;
9417     VkObjectType       objectType;
9418     uint64_t           objectHandle;
9419     const char*        pObjectName;
9420 } VkDebugUtilsObjectNameInfoEXT;
9421 
9422 typedef struct VkDebugUtilsMessengerCallbackDataEXT {
9423     VkStructureType                              sType;
9424     const void*                                  pNext;
9425     VkDebugUtilsMessengerCallbackDataFlagsEXT    flags;
9426     const char*                                  pMessageIdName;
9427     int32_t                                      messageIdNumber;
9428     const char*                                  pMessage;
9429     uint32_t                                     queueLabelCount;
9430     const VkDebugUtilsLabelEXT*                  pQueueLabels;
9431     uint32_t                                     cmdBufLabelCount;
9432     const VkDebugUtilsLabelEXT*                  pCmdBufLabels;
9433     uint32_t                                     objectCount;
9434     const VkDebugUtilsObjectNameInfoEXT*         pObjects;
9435 } VkDebugUtilsMessengerCallbackDataEXT;
9436 
9437 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(
9438     VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
9439     VkDebugUtilsMessageTypeFlagsEXT                  messageTypes,
9440     const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
9441     void*                                            pUserData);
9442 
9443 typedef struct VkDebugUtilsMessengerCreateInfoEXT {
9444     VkStructureType                         sType;
9445     const void*                             pNext;
9446     VkDebugUtilsMessengerCreateFlagsEXT     flags;
9447     VkDebugUtilsMessageSeverityFlagsEXT     messageSeverity;
9448     VkDebugUtilsMessageTypeFlagsEXT         messageType;
9449     PFN_vkDebugUtilsMessengerCallbackEXT    pfnUserCallback;
9450     void*                                   pUserData;
9451 } VkDebugUtilsMessengerCreateInfoEXT;
9452 
9453 typedef struct VkDebugUtilsObjectTagInfoEXT {
9454     VkStructureType    sType;
9455     const void*        pNext;
9456     VkObjectType       objectType;
9457     uint64_t           objectHandle;
9458     uint64_t           tagName;
9459     size_t             tagSize;
9460     const void*        pTag;
9461 } VkDebugUtilsObjectTagInfoEXT;
9462 
9463 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
9464 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
9465 typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
9466 typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue);
9467 typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
9468 typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
9469 typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer);
9470 typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
9471 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
9472 typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
9473 typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
9474 
9475 #ifndef VK_NO_PROTOTYPES
9476 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(
9477     VkDevice                                    device,
9478     const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);
9479 
9480 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(
9481     VkDevice                                    device,
9482     const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);
9483 
9484 VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(
9485     VkQueue                                     queue,
9486     const VkDebugUtilsLabelEXT*                 pLabelInfo);
9487 
9488 VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(
9489     VkQueue                                     queue);
9490 
9491 VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(
9492     VkQueue                                     queue,
9493     const VkDebugUtilsLabelEXT*                 pLabelInfo);
9494 
9495 VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(
9496     VkCommandBuffer                             commandBuffer,
9497     const VkDebugUtilsLabelEXT*                 pLabelInfo);
9498 
9499 VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(
9500     VkCommandBuffer                             commandBuffer);
9501 
9502 VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(
9503     VkCommandBuffer                             commandBuffer,
9504     const VkDebugUtilsLabelEXT*                 pLabelInfo);
9505 
9506 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(
9507     VkInstance                                  instance,
9508     const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
9509     const VkAllocationCallbacks*                pAllocator,
9510     VkDebugUtilsMessengerEXT*                   pMessenger);
9511 
9512 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(
9513     VkInstance                                  instance,
9514     VkDebugUtilsMessengerEXT                    messenger,
9515     const VkAllocationCallbacks*                pAllocator);
9516 
9517 VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(
9518     VkInstance                                  instance,
9519     VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
9520     VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
9521     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
9522 #endif
9523 
9524 
9525 #define VK_EXT_sampler_filter_minmax 1
9526 #define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2
9527 #define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
9528 typedef VkSamplerReductionMode VkSamplerReductionModeEXT;
9529 
9530 typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT;
9531 
9532 typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
9533 
9534 
9535 
9536 #define VK_AMD_gpu_shader_int16 1
9537 #define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2
9538 #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
9539 
9540 
9541 #define VK_AMD_mixed_attachment_samples 1
9542 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
9543 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
9544 
9545 
9546 #define VK_AMD_shader_fragment_mask 1
9547 #define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
9548 #define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"
9549 
9550 
9551 #define VK_EXT_inline_uniform_block 1
9552 #define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1
9553 #define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block"
9554 typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT {
9555     VkStructureType    sType;
9556     void*              pNext;
9557     VkBool32           inlineUniformBlock;
9558     VkBool32           descriptorBindingInlineUniformBlockUpdateAfterBind;
9559 } VkPhysicalDeviceInlineUniformBlockFeaturesEXT;
9560 
9561 typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT {
9562     VkStructureType    sType;
9563     void*              pNext;
9564     uint32_t           maxInlineUniformBlockSize;
9565     uint32_t           maxPerStageDescriptorInlineUniformBlocks;
9566     uint32_t           maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
9567     uint32_t           maxDescriptorSetInlineUniformBlocks;
9568     uint32_t           maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
9569 } VkPhysicalDeviceInlineUniformBlockPropertiesEXT;
9570 
9571 typedef struct VkWriteDescriptorSetInlineUniformBlockEXT {
9572     VkStructureType    sType;
9573     const void*        pNext;
9574     uint32_t           dataSize;
9575     const void*        pData;
9576 } VkWriteDescriptorSetInlineUniformBlockEXT;
9577 
9578 typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT {
9579     VkStructureType    sType;
9580     const void*        pNext;
9581     uint32_t           maxInlineUniformBlockBindings;
9582 } VkDescriptorPoolInlineUniformBlockCreateInfoEXT;
9583 
9584 
9585 
9586 #define VK_EXT_shader_stencil_export 1
9587 #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
9588 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
9589 
9590 
9591 #define VK_EXT_sample_locations 1
9592 #define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
9593 #define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"
9594 typedef struct VkSampleLocationEXT {
9595     float    x;
9596     float    y;
9597 } VkSampleLocationEXT;
9598 
9599 typedef struct VkSampleLocationsInfoEXT {
9600     VkStructureType               sType;
9601     const void*                   pNext;
9602     VkSampleCountFlagBits         sampleLocationsPerPixel;
9603     VkExtent2D                    sampleLocationGridSize;
9604     uint32_t                      sampleLocationsCount;
9605     const VkSampleLocationEXT*    pSampleLocations;
9606 } VkSampleLocationsInfoEXT;
9607 
9608 typedef struct VkAttachmentSampleLocationsEXT {
9609     uint32_t                    attachmentIndex;
9610     VkSampleLocationsInfoEXT    sampleLocationsInfo;
9611 } VkAttachmentSampleLocationsEXT;
9612 
9613 typedef struct VkSubpassSampleLocationsEXT {
9614     uint32_t                    subpassIndex;
9615     VkSampleLocationsInfoEXT    sampleLocationsInfo;
9616 } VkSubpassSampleLocationsEXT;
9617 
9618 typedef struct VkRenderPassSampleLocationsBeginInfoEXT {
9619     VkStructureType                          sType;
9620     const void*                              pNext;
9621     uint32_t                                 attachmentInitialSampleLocationsCount;
9622     const VkAttachmentSampleLocationsEXT*    pAttachmentInitialSampleLocations;
9623     uint32_t                                 postSubpassSampleLocationsCount;
9624     const VkSubpassSampleLocationsEXT*       pPostSubpassSampleLocations;
9625 } VkRenderPassSampleLocationsBeginInfoEXT;
9626 
9627 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {
9628     VkStructureType             sType;
9629     const void*                 pNext;
9630     VkBool32                    sampleLocationsEnable;
9631     VkSampleLocationsInfoEXT    sampleLocationsInfo;
9632 } VkPipelineSampleLocationsStateCreateInfoEXT;
9633 
9634 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
9635     VkStructureType       sType;
9636     void*                 pNext;
9637     VkSampleCountFlags    sampleLocationSampleCounts;
9638     VkExtent2D            maxSampleLocationGridSize;
9639     float                 sampleLocationCoordinateRange[2];
9640     uint32_t              sampleLocationSubPixelBits;
9641     VkBool32              variableSampleLocations;
9642 } VkPhysicalDeviceSampleLocationsPropertiesEXT;
9643 
9644 typedef struct VkMultisamplePropertiesEXT {
9645     VkStructureType    sType;
9646     void*              pNext;
9647     VkExtent2D         maxSampleLocationGridSize;
9648 } VkMultisamplePropertiesEXT;
9649 
9650 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
9651 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);
9652 
9653 #ifndef VK_NO_PROTOTYPES
9654 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(
9655     VkCommandBuffer                             commandBuffer,
9656     const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
9657 
9658 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(
9659     VkPhysicalDevice                            physicalDevice,
9660     VkSampleCountFlagBits                       samples,
9661     VkMultisamplePropertiesEXT*                 pMultisampleProperties);
9662 #endif
9663 
9664 
9665 #define VK_EXT_blend_operation_advanced 1
9666 #define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
9667 #define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
9668 
9669 typedef enum VkBlendOverlapEXT {
9670     VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
9671     VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
9672     VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
9673     VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
9674 } VkBlendOverlapEXT;
9675 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
9676     VkStructureType    sType;
9677     void*              pNext;
9678     VkBool32           advancedBlendCoherentOperations;
9679 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
9680 
9681 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
9682     VkStructureType    sType;
9683     void*              pNext;
9684     uint32_t           advancedBlendMaxColorAttachments;
9685     VkBool32           advancedBlendIndependentBlend;
9686     VkBool32           advancedBlendNonPremultipliedSrcColor;
9687     VkBool32           advancedBlendNonPremultipliedDstColor;
9688     VkBool32           advancedBlendCorrelatedOverlap;
9689     VkBool32           advancedBlendAllOperations;
9690 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
9691 
9692 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
9693     VkStructureType      sType;
9694     const void*          pNext;
9695     VkBool32             srcPremultiplied;
9696     VkBool32             dstPremultiplied;
9697     VkBlendOverlapEXT    blendOverlap;
9698 } VkPipelineColorBlendAdvancedStateCreateInfoEXT;
9699 
9700 
9701 
9702 #define VK_NV_fragment_coverage_to_color 1
9703 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
9704 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
9705 typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
9706 typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
9707     VkStructureType                                sType;
9708     const void*                                    pNext;
9709     VkPipelineCoverageToColorStateCreateFlagsNV    flags;
9710     VkBool32                                       coverageToColorEnable;
9711     uint32_t                                       coverageToColorLocation;
9712 } VkPipelineCoverageToColorStateCreateInfoNV;
9713 
9714 
9715 
9716 #define VK_NV_framebuffer_mixed_samples 1
9717 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
9718 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
9719 
9720 typedef enum VkCoverageModulationModeNV {
9721     VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
9722     VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
9723     VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
9724     VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
9725     VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
9726 } VkCoverageModulationModeNV;
9727 typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
9728 typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
9729     VkStructureType                                   sType;
9730     const void*                                       pNext;
9731     VkPipelineCoverageModulationStateCreateFlagsNV    flags;
9732     VkCoverageModulationModeNV                        coverageModulationMode;
9733     VkBool32                                          coverageModulationTableEnable;
9734     uint32_t                                          coverageModulationTableCount;
9735     const float*                                      pCoverageModulationTable;
9736 } VkPipelineCoverageModulationStateCreateInfoNV;
9737 
9738 
9739 
9740 #define VK_NV_fill_rectangle 1
9741 #define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
9742 #define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
9743 
9744 
9745 #define VK_NV_shader_sm_builtins 1
9746 #define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1
9747 #define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins"
9748 typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
9749     VkStructureType    sType;
9750     void*              pNext;
9751     uint32_t           shaderSMCount;
9752     uint32_t           shaderWarpsPerSM;
9753 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;
9754 
9755 typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
9756     VkStructureType    sType;
9757     void*              pNext;
9758     VkBool32           shaderSMBuiltins;
9759 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
9760 
9761 
9762 
9763 #define VK_EXT_post_depth_coverage 1
9764 #define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
9765 #define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
9766 
9767 
9768 #define VK_EXT_image_drm_format_modifier 1
9769 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1
9770 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier"
9771 typedef struct VkDrmFormatModifierPropertiesEXT {
9772     uint64_t                drmFormatModifier;
9773     uint32_t                drmFormatModifierPlaneCount;
9774     VkFormatFeatureFlags    drmFormatModifierTilingFeatures;
9775 } VkDrmFormatModifierPropertiesEXT;
9776 
9777 typedef struct VkDrmFormatModifierPropertiesListEXT {
9778     VkStructureType                      sType;
9779     void*                                pNext;
9780     uint32_t                             drmFormatModifierCount;
9781     VkDrmFormatModifierPropertiesEXT*    pDrmFormatModifierProperties;
9782 } VkDrmFormatModifierPropertiesListEXT;
9783 
9784 typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
9785     VkStructureType    sType;
9786     const void*        pNext;
9787     uint64_t           drmFormatModifier;
9788     VkSharingMode      sharingMode;
9789     uint32_t           queueFamilyIndexCount;
9790     const uint32_t*    pQueueFamilyIndices;
9791 } VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
9792 
9793 typedef struct VkImageDrmFormatModifierListCreateInfoEXT {
9794     VkStructureType    sType;
9795     const void*        pNext;
9796     uint32_t           drmFormatModifierCount;
9797     const uint64_t*    pDrmFormatModifiers;
9798 } VkImageDrmFormatModifierListCreateInfoEXT;
9799 
9800 typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
9801     VkStructureType               sType;
9802     const void*                   pNext;
9803     uint64_t                      drmFormatModifier;
9804     uint32_t                      drmFormatModifierPlaneCount;
9805     const VkSubresourceLayout*    pPlaneLayouts;
9806 } VkImageDrmFormatModifierExplicitCreateInfoEXT;
9807 
9808 typedef struct VkImageDrmFormatModifierPropertiesEXT {
9809     VkStructureType    sType;
9810     void*              pNext;
9811     uint64_t           drmFormatModifier;
9812 } VkImageDrmFormatModifierPropertiesEXT;
9813 
9814 typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties);
9815 
9816 #ifndef VK_NO_PROTOTYPES
9817 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(
9818     VkDevice                                    device,
9819     VkImage                                     image,
9820     VkImageDrmFormatModifierPropertiesEXT*      pProperties);
9821 #endif
9822 
9823 
9824 #define VK_EXT_validation_cache 1
9825 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
9826 #define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
9827 #define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"
9828 
9829 typedef enum VkValidationCacheHeaderVersionEXT {
9830     VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,
9831     VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF
9832 } VkValidationCacheHeaderVersionEXT;
9833 typedef VkFlags VkValidationCacheCreateFlagsEXT;
9834 typedef struct VkValidationCacheCreateInfoEXT {
9835     VkStructureType                    sType;
9836     const void*                        pNext;
9837     VkValidationCacheCreateFlagsEXT    flags;
9838     size_t                             initialDataSize;
9839     const void*                        pInitialData;
9840 } VkValidationCacheCreateInfoEXT;
9841 
9842 typedef struct VkShaderModuleValidationCacheCreateInfoEXT {
9843     VkStructureType         sType;
9844     const void*             pNext;
9845     VkValidationCacheEXT    validationCache;
9846 } VkShaderModuleValidationCacheCreateInfoEXT;
9847 
9848 typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);
9849 typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);
9850 typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);
9851 typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);
9852 
9853 #ifndef VK_NO_PROTOTYPES
9854 VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(
9855     VkDevice                                    device,
9856     const VkValidationCacheCreateInfoEXT*       pCreateInfo,
9857     const VkAllocationCallbacks*                pAllocator,
9858     VkValidationCacheEXT*                       pValidationCache);
9859 
9860 VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(
9861     VkDevice                                    device,
9862     VkValidationCacheEXT                        validationCache,
9863     const VkAllocationCallbacks*                pAllocator);
9864 
9865 VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(
9866     VkDevice                                    device,
9867     VkValidationCacheEXT                        dstCache,
9868     uint32_t                                    srcCacheCount,
9869     const VkValidationCacheEXT*                 pSrcCaches);
9870 
9871 VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(
9872     VkDevice                                    device,
9873     VkValidationCacheEXT                        validationCache,
9874     size_t*                                     pDataSize,
9875     void*                                       pData);
9876 #endif
9877 
9878 
9879 #define VK_EXT_descriptor_indexing 1
9880 #define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
9881 #define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"
9882 typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT;
9883 
9884 typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT;
9885 
9886 typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;
9887 
9888 typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT;
9889 
9890 typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT;
9891 
9892 typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;
9893 
9894 typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;
9895 
9896 
9897 
9898 #define VK_EXT_shader_viewport_index_layer 1
9899 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
9900 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
9901 
9902 
9903 #define VK_NV_shading_rate_image 1
9904 #define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3
9905 #define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"
9906 
9907 typedef enum VkShadingRatePaletteEntryNV {
9908     VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0,
9909     VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1,
9910     VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2,
9911     VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3,
9912     VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4,
9913     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5,
9914     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,
9915     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,
9916     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,
9917     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
9918     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,
9919     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11,
9920     VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF
9921 } VkShadingRatePaletteEntryNV;
9922 
9923 typedef enum VkCoarseSampleOrderTypeNV {
9924     VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0,
9925     VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1,
9926     VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2,
9927     VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3,
9928     VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
9929 } VkCoarseSampleOrderTypeNV;
9930 typedef struct VkShadingRatePaletteNV {
9931     uint32_t                              shadingRatePaletteEntryCount;
9932     const VkShadingRatePaletteEntryNV*    pShadingRatePaletteEntries;
9933 } VkShadingRatePaletteNV;
9934 
9935 typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
9936     VkStructureType                  sType;
9937     const void*                      pNext;
9938     VkBool32                         shadingRateImageEnable;
9939     uint32_t                         viewportCount;
9940     const VkShadingRatePaletteNV*    pShadingRatePalettes;
9941 } VkPipelineViewportShadingRateImageStateCreateInfoNV;
9942 
9943 typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV {
9944     VkStructureType    sType;
9945     void*              pNext;
9946     VkBool32           shadingRateImage;
9947     VkBool32           shadingRateCoarseSampleOrder;
9948 } VkPhysicalDeviceShadingRateImageFeaturesNV;
9949 
9950 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV {
9951     VkStructureType    sType;
9952     void*              pNext;
9953     VkExtent2D         shadingRateTexelSize;
9954     uint32_t           shadingRatePaletteSize;
9955     uint32_t           shadingRateMaxCoarseSamples;
9956 } VkPhysicalDeviceShadingRateImagePropertiesNV;
9957 
9958 typedef struct VkCoarseSampleLocationNV {
9959     uint32_t    pixelX;
9960     uint32_t    pixelY;
9961     uint32_t    sample;
9962 } VkCoarseSampleLocationNV;
9963 
9964 typedef struct VkCoarseSampleOrderCustomNV {
9965     VkShadingRatePaletteEntryNV        shadingRate;
9966     uint32_t                           sampleCount;
9967     uint32_t                           sampleLocationCount;
9968     const VkCoarseSampleLocationNV*    pSampleLocations;
9969 } VkCoarseSampleOrderCustomNV;
9970 
9971 typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
9972     VkStructureType                       sType;
9973     const void*                           pNext;
9974     VkCoarseSampleOrderTypeNV             sampleOrderType;
9975     uint32_t                              customSampleOrderCount;
9976     const VkCoarseSampleOrderCustomNV*    pCustomSampleOrders;
9977 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
9978 
9979 typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
9980 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes);
9981 typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
9982 
9983 #ifndef VK_NO_PROTOTYPES
9984 VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(
9985     VkCommandBuffer                             commandBuffer,
9986     VkImageView                                 imageView,
9987     VkImageLayout                               imageLayout);
9988 
9989 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(
9990     VkCommandBuffer                             commandBuffer,
9991     uint32_t                                    firstViewport,
9992     uint32_t                                    viewportCount,
9993     const VkShadingRatePaletteNV*               pShadingRatePalettes);
9994 
9995 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(
9996     VkCommandBuffer                             commandBuffer,
9997     VkCoarseSampleOrderTypeNV                   sampleOrderType,
9998     uint32_t                                    customSampleOrderCount,
9999     const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);
10000 #endif
10001 
10002 
10003 #define VK_NV_ray_tracing 1
10004 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)
10005 #define VK_NV_RAY_TRACING_SPEC_VERSION    3
10006 #define VK_NV_RAY_TRACING_EXTENSION_NAME  "VK_NV_ray_tracing"
10007 #define VK_SHADER_UNUSED_KHR              (~0U)
10008 #define VK_SHADER_UNUSED_NV               VK_SHADER_UNUSED_KHR
10009 
10010 typedef enum VkRayTracingShaderGroupTypeKHR {
10011     VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0,
10012     VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1,
10013     VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2,
10014     VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
10015     VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
10016     VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR,
10017     VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
10018 } VkRayTracingShaderGroupTypeKHR;
10019 typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV;
10020 
10021 
10022 typedef enum VkGeometryTypeKHR {
10023     VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0,
10024     VK_GEOMETRY_TYPE_AABBS_KHR = 1,
10025     VK_GEOMETRY_TYPE_INSTANCES_KHR = 2,
10026     VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
10027     VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR,
10028     VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
10029 } VkGeometryTypeKHR;
10030 typedef VkGeometryTypeKHR VkGeometryTypeNV;
10031 
10032 
10033 typedef enum VkAccelerationStructureTypeKHR {
10034     VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0,
10035     VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1,
10036     VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2,
10037     VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR,
10038     VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
10039     VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
10040 } VkAccelerationStructureTypeKHR;
10041 typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV;
10042 
10043 
10044 typedef enum VkCopyAccelerationStructureModeKHR {
10045     VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0,
10046     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1,
10047     VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2,
10048     VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3,
10049     VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR,
10050     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR,
10051     VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
10052 } VkCopyAccelerationStructureModeKHR;
10053 typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV;
10054 
10055 
10056 typedef enum VkAccelerationStructureMemoryRequirementsTypeNV {
10057     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0,
10058     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1,
10059     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2,
10060     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
10061 } VkAccelerationStructureMemoryRequirementsTypeNV;
10062 
10063 typedef enum VkGeometryFlagBitsKHR {
10064     VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001,
10065     VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002,
10066     VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR,
10067     VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR,
10068     VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
10069 } VkGeometryFlagBitsKHR;
10070 typedef VkFlags VkGeometryFlagsKHR;
10071 typedef VkGeometryFlagsKHR VkGeometryFlagsNV;
10072 
10073 typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV;
10074 
10075 
10076 typedef enum VkGeometryInstanceFlagBitsKHR {
10077     VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001,
10078     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = 0x00000002,
10079     VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004,
10080     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008,
10081     VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,
10082     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR,
10083     VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR,
10084     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR,
10085     VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
10086 } VkGeometryInstanceFlagBitsKHR;
10087 typedef VkFlags VkGeometryInstanceFlagsKHR;
10088 typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV;
10089 
10090 typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV;
10091 
10092 
10093 typedef enum VkBuildAccelerationStructureFlagBitsKHR {
10094     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001,
10095     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002,
10096     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004,
10097     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008,
10098     VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010,
10099     VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020,
10100     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,
10101     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR,
10102     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
10103     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR,
10104     VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR,
10105     VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
10106 } VkBuildAccelerationStructureFlagBitsKHR;
10107 typedef VkFlags VkBuildAccelerationStructureFlagsKHR;
10108 typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV;
10109 
10110 typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV;
10111 
10112 typedef struct VkRayTracingShaderGroupCreateInfoNV {
10113     VkStructureType                   sType;
10114     const void*                       pNext;
10115     VkRayTracingShaderGroupTypeKHR    type;
10116     uint32_t                          generalShader;
10117     uint32_t                          closestHitShader;
10118     uint32_t                          anyHitShader;
10119     uint32_t                          intersectionShader;
10120 } VkRayTracingShaderGroupCreateInfoNV;
10121 
10122 typedef struct VkRayTracingPipelineCreateInfoNV {
10123     VkStructureType                               sType;
10124     const void*                                   pNext;
10125     VkPipelineCreateFlags                         flags;
10126     uint32_t                                      stageCount;
10127     const VkPipelineShaderStageCreateInfo*        pStages;
10128     uint32_t                                      groupCount;
10129     const VkRayTracingShaderGroupCreateInfoNV*    pGroups;
10130     uint32_t                                      maxRecursionDepth;
10131     VkPipelineLayout                              layout;
10132     VkPipeline                                    basePipelineHandle;
10133     int32_t                                       basePipelineIndex;
10134 } VkRayTracingPipelineCreateInfoNV;
10135 
10136 typedef struct VkGeometryTrianglesNV {
10137     VkStructureType    sType;
10138     const void*        pNext;
10139     VkBuffer           vertexData;
10140     VkDeviceSize       vertexOffset;
10141     uint32_t           vertexCount;
10142     VkDeviceSize       vertexStride;
10143     VkFormat           vertexFormat;
10144     VkBuffer           indexData;
10145     VkDeviceSize       indexOffset;
10146     uint32_t           indexCount;
10147     VkIndexType        indexType;
10148     VkBuffer           transformData;
10149     VkDeviceSize       transformOffset;
10150 } VkGeometryTrianglesNV;
10151 
10152 typedef struct VkGeometryAABBNV {
10153     VkStructureType    sType;
10154     const void*        pNext;
10155     VkBuffer           aabbData;
10156     uint32_t           numAABBs;
10157     uint32_t           stride;
10158     VkDeviceSize       offset;
10159 } VkGeometryAABBNV;
10160 
10161 typedef struct VkGeometryDataNV {
10162     VkGeometryTrianglesNV    triangles;
10163     VkGeometryAABBNV         aabbs;
10164 } VkGeometryDataNV;
10165 
10166 typedef struct VkGeometryNV {
10167     VkStructureType       sType;
10168     const void*           pNext;
10169     VkGeometryTypeKHR     geometryType;
10170     VkGeometryDataNV      geometry;
10171     VkGeometryFlagsKHR    flags;
10172 } VkGeometryNV;
10173 
10174 typedef struct VkAccelerationStructureInfoNV {
10175     VkStructureType                        sType;
10176     const void*                            pNext;
10177     VkAccelerationStructureTypeNV          type;
10178     VkBuildAccelerationStructureFlagsNV    flags;
10179     uint32_t                               instanceCount;
10180     uint32_t                               geometryCount;
10181     const VkGeometryNV*                    pGeometries;
10182 } VkAccelerationStructureInfoNV;
10183 
10184 typedef struct VkAccelerationStructureCreateInfoNV {
10185     VkStructureType                  sType;
10186     const void*                      pNext;
10187     VkDeviceSize                     compactedSize;
10188     VkAccelerationStructureInfoNV    info;
10189 } VkAccelerationStructureCreateInfoNV;
10190 
10191 typedef struct VkBindAccelerationStructureMemoryInfoNV {
10192     VkStructureType              sType;
10193     const void*                  pNext;
10194     VkAccelerationStructureNV    accelerationStructure;
10195     VkDeviceMemory               memory;
10196     VkDeviceSize                 memoryOffset;
10197     uint32_t                     deviceIndexCount;
10198     const uint32_t*              pDeviceIndices;
10199 } VkBindAccelerationStructureMemoryInfoNV;
10200 
10201 typedef struct VkWriteDescriptorSetAccelerationStructureNV {
10202     VkStructureType                     sType;
10203     const void*                         pNext;
10204     uint32_t                            accelerationStructureCount;
10205     const VkAccelerationStructureNV*    pAccelerationStructures;
10206 } VkWriteDescriptorSetAccelerationStructureNV;
10207 
10208 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV {
10209     VkStructureType                                    sType;
10210     const void*                                        pNext;
10211     VkAccelerationStructureMemoryRequirementsTypeNV    type;
10212     VkAccelerationStructureNV                          accelerationStructure;
10213 } VkAccelerationStructureMemoryRequirementsInfoNV;
10214 
10215 typedef struct VkPhysicalDeviceRayTracingPropertiesNV {
10216     VkStructureType    sType;
10217     void*              pNext;
10218     uint32_t           shaderGroupHandleSize;
10219     uint32_t           maxRecursionDepth;
10220     uint32_t           maxShaderGroupStride;
10221     uint32_t           shaderGroupBaseAlignment;
10222     uint64_t           maxGeometryCount;
10223     uint64_t           maxInstanceCount;
10224     uint64_t           maxTriangleCount;
10225     uint32_t           maxDescriptorSetAccelerationStructures;
10226 } VkPhysicalDeviceRayTracingPropertiesNV;
10227 
10228 typedef struct VkTransformMatrixKHR {
10229     float    matrix[3][4];
10230 } VkTransformMatrixKHR;
10231 
10232 typedef VkTransformMatrixKHR VkTransformMatrixNV;
10233 
10234 typedef struct VkAabbPositionsKHR {
10235     float    minX;
10236     float    minY;
10237     float    minZ;
10238     float    maxX;
10239     float    maxY;
10240     float    maxZ;
10241 } VkAabbPositionsKHR;
10242 
10243 typedef VkAabbPositionsKHR VkAabbPositionsNV;
10244 
10245 typedef struct VkAccelerationStructureInstanceKHR {
10246     VkTransformMatrixKHR          transform;
10247     uint32_t                      instanceCustomIndex:24;
10248     uint32_t                      mask:8;
10249     uint32_t                      instanceShaderBindingTableRecordOffset:24;
10250     VkGeometryInstanceFlagsKHR    flags:8;
10251     uint64_t                      accelerationStructureReference;
10252 } VkAccelerationStructureInstanceKHR;
10253 
10254 typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV;
10255 
10256 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure);
10257 typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator);
10258 typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
10259 typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
10260 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset);
10261 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode);
10262 typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth);
10263 typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
10264 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
10265 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
10266 typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData);
10267 typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
10268 typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader);
10269 
10270 #ifndef VK_NO_PROTOTYPES
10271 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(
10272     VkDevice                                    device,
10273     const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
10274     const VkAllocationCallbacks*                pAllocator,
10275     VkAccelerationStructureNV*                  pAccelerationStructure);
10276 
10277 VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(
10278     VkDevice                                    device,
10279     VkAccelerationStructureNV                   accelerationStructure,
10280     const VkAllocationCallbacks*                pAllocator);
10281 
10282 VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(
10283     VkDevice                                    device,
10284     const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
10285     VkMemoryRequirements2KHR*                   pMemoryRequirements);
10286 
10287 VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(
10288     VkDevice                                    device,
10289     uint32_t                                    bindInfoCount,
10290     const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
10291 
10292 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(
10293     VkCommandBuffer                             commandBuffer,
10294     const VkAccelerationStructureInfoNV*        pInfo,
10295     VkBuffer                                    instanceData,
10296     VkDeviceSize                                instanceOffset,
10297     VkBool32                                    update,
10298     VkAccelerationStructureNV                   dst,
10299     VkAccelerationStructureNV                   src,
10300     VkBuffer                                    scratch,
10301     VkDeviceSize                                scratchOffset);
10302 
10303 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(
10304     VkCommandBuffer                             commandBuffer,
10305     VkAccelerationStructureNV                   dst,
10306     VkAccelerationStructureNV                   src,
10307     VkCopyAccelerationStructureModeKHR          mode);
10308 
10309 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV(
10310     VkCommandBuffer                             commandBuffer,
10311     VkBuffer                                    raygenShaderBindingTableBuffer,
10312     VkDeviceSize                                raygenShaderBindingOffset,
10313     VkBuffer                                    missShaderBindingTableBuffer,
10314     VkDeviceSize                                missShaderBindingOffset,
10315     VkDeviceSize                                missShaderBindingStride,
10316     VkBuffer                                    hitShaderBindingTableBuffer,
10317     VkDeviceSize                                hitShaderBindingOffset,
10318     VkDeviceSize                                hitShaderBindingStride,
10319     VkBuffer                                    callableShaderBindingTableBuffer,
10320     VkDeviceSize                                callableShaderBindingOffset,
10321     VkDeviceSize                                callableShaderBindingStride,
10322     uint32_t                                    width,
10323     uint32_t                                    height,
10324     uint32_t                                    depth);
10325 
10326 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(
10327     VkDevice                                    device,
10328     VkPipelineCache                             pipelineCache,
10329     uint32_t                                    createInfoCount,
10330     const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
10331     const VkAllocationCallbacks*                pAllocator,
10332     VkPipeline*                                 pPipelines);
10333 
10334 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(
10335     VkDevice                                    device,
10336     VkPipeline                                  pipeline,
10337     uint32_t                                    firstGroup,
10338     uint32_t                                    groupCount,
10339     size_t                                      dataSize,
10340     void*                                       pData);
10341 
10342 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(
10343     VkDevice                                    device,
10344     VkPipeline                                  pipeline,
10345     uint32_t                                    firstGroup,
10346     uint32_t                                    groupCount,
10347     size_t                                      dataSize,
10348     void*                                       pData);
10349 
10350 VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(
10351     VkDevice                                    device,
10352     VkAccelerationStructureNV                   accelerationStructure,
10353     size_t                                      dataSize,
10354     void*                                       pData);
10355 
10356 VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(
10357     VkCommandBuffer                             commandBuffer,
10358     uint32_t                                    accelerationStructureCount,
10359     const VkAccelerationStructureNV*            pAccelerationStructures,
10360     VkQueryType                                 queryType,
10361     VkQueryPool                                 queryPool,
10362     uint32_t                                    firstQuery);
10363 
10364 VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(
10365     VkDevice                                    device,
10366     VkPipeline                                  pipeline,
10367     uint32_t                                    shader);
10368 #endif
10369 
10370 
10371 #define VK_NV_representative_fragment_test 1
10372 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2
10373 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
10374 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
10375     VkStructureType    sType;
10376     void*              pNext;
10377     VkBool32           representativeFragmentTest;
10378 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
10379 
10380 typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
10381     VkStructureType    sType;
10382     const void*        pNext;
10383     VkBool32           representativeFragmentTestEnable;
10384 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
10385 
10386 
10387 
10388 #define VK_EXT_filter_cubic 1
10389 #define VK_EXT_FILTER_CUBIC_SPEC_VERSION  3
10390 #define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic"
10391 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
10392     VkStructureType    sType;
10393     void*              pNext;
10394     VkImageViewType    imageViewType;
10395 } VkPhysicalDeviceImageViewImageFormatInfoEXT;
10396 
10397 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT {
10398     VkStructureType    sType;
10399     void*              pNext;
10400     VkBool32           filterCubic;
10401     VkBool32           filterCubicMinmax;
10402 } VkFilterCubicImageViewImageFormatPropertiesEXT;
10403 
10404 
10405 
10406 #define VK_QCOM_render_pass_shader_resolve 1
10407 #define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4
10408 #define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve"
10409 
10410 
10411 #define VK_EXT_global_priority 1
10412 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
10413 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
10414 
10415 typedef enum VkQueueGlobalPriorityEXT {
10416     VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128,
10417     VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256,
10418     VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512,
10419     VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024,
10420     VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF
10421 } VkQueueGlobalPriorityEXT;
10422 typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT {
10423     VkStructureType             sType;
10424     const void*                 pNext;
10425     VkQueueGlobalPriorityEXT    globalPriority;
10426 } VkDeviceQueueGlobalPriorityCreateInfoEXT;
10427 
10428 
10429 
10430 #define VK_EXT_external_memory_host 1
10431 #define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
10432 #define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"
10433 typedef struct VkImportMemoryHostPointerInfoEXT {
10434     VkStructureType                       sType;
10435     const void*                           pNext;
10436     VkExternalMemoryHandleTypeFlagBits    handleType;
10437     void*                                 pHostPointer;
10438 } VkImportMemoryHostPointerInfoEXT;
10439 
10440 typedef struct VkMemoryHostPointerPropertiesEXT {
10441     VkStructureType    sType;
10442     void*              pNext;
10443     uint32_t           memoryTypeBits;
10444 } VkMemoryHostPointerPropertiesEXT;
10445 
10446 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
10447     VkStructureType    sType;
10448     void*              pNext;
10449     VkDeviceSize       minImportedHostPointerAlignment;
10450 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
10451 
10452 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
10453 
10454 #ifndef VK_NO_PROTOTYPES
10455 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(
10456     VkDevice                                    device,
10457     VkExternalMemoryHandleTypeFlagBits          handleType,
10458     const void*                                 pHostPointer,
10459     VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
10460 #endif
10461 
10462 
10463 #define VK_AMD_buffer_marker 1
10464 #define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1
10465 #define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"
10466 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
10467 
10468 #ifndef VK_NO_PROTOTYPES
10469 VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(
10470     VkCommandBuffer                             commandBuffer,
10471     VkPipelineStageFlagBits                     pipelineStage,
10472     VkBuffer                                    dstBuffer,
10473     VkDeviceSize                                dstOffset,
10474     uint32_t                                    marker);
10475 #endif
10476 
10477 
10478 #define VK_AMD_pipeline_compiler_control 1
10479 #define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1
10480 #define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control"
10481 
10482 typedef enum VkPipelineCompilerControlFlagBitsAMD {
10483     VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
10484 } VkPipelineCompilerControlFlagBitsAMD;
10485 typedef VkFlags VkPipelineCompilerControlFlagsAMD;
10486 typedef struct VkPipelineCompilerControlCreateInfoAMD {
10487     VkStructureType                      sType;
10488     const void*                          pNext;
10489     VkPipelineCompilerControlFlagsAMD    compilerControlFlags;
10490 } VkPipelineCompilerControlCreateInfoAMD;
10491 
10492 
10493 
10494 #define VK_EXT_calibrated_timestamps 1
10495 #define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2
10496 #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
10497 
10498 typedef enum VkTimeDomainEXT {
10499     VK_TIME_DOMAIN_DEVICE_EXT = 0,
10500     VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,
10501     VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,
10502     VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,
10503     VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
10504 } VkTimeDomainEXT;
10505 typedef struct VkCalibratedTimestampInfoEXT {
10506     VkStructureType    sType;
10507     const void*        pNext;
10508     VkTimeDomainEXT    timeDomain;
10509 } VkCalibratedTimestampInfoEXT;
10510 
10511 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);
10512 typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
10513 
10514 #ifndef VK_NO_PROTOTYPES
10515 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
10516     VkPhysicalDevice                            physicalDevice,
10517     uint32_t*                                   pTimeDomainCount,
10518     VkTimeDomainEXT*                            pTimeDomains);
10519 
10520 VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(
10521     VkDevice                                    device,
10522     uint32_t                                    timestampCount,
10523     const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
10524     uint64_t*                                   pTimestamps,
10525     uint64_t*                                   pMaxDeviation);
10526 #endif
10527 
10528 
10529 #define VK_AMD_shader_core_properties 1
10530 #define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2
10531 #define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"
10532 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
10533     VkStructureType    sType;
10534     void*              pNext;
10535     uint32_t           shaderEngineCount;
10536     uint32_t           shaderArraysPerEngineCount;
10537     uint32_t           computeUnitsPerShaderArray;
10538     uint32_t           simdPerComputeUnit;
10539     uint32_t           wavefrontsPerSimd;
10540     uint32_t           wavefrontSize;
10541     uint32_t           sgprsPerSimd;
10542     uint32_t           minSgprAllocation;
10543     uint32_t           maxSgprAllocation;
10544     uint32_t           sgprAllocationGranularity;
10545     uint32_t           vgprsPerSimd;
10546     uint32_t           minVgprAllocation;
10547     uint32_t           maxVgprAllocation;
10548     uint32_t           vgprAllocationGranularity;
10549 } VkPhysicalDeviceShaderCorePropertiesAMD;
10550 
10551 
10552 
10553 #define VK_AMD_memory_overallocation_behavior 1
10554 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1
10555 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior"
10556 
10557 typedef enum VkMemoryOverallocationBehaviorAMD {
10558     VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0,
10559     VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1,
10560     VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2,
10561     VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF
10562 } VkMemoryOverallocationBehaviorAMD;
10563 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD {
10564     VkStructureType                      sType;
10565     const void*                          pNext;
10566     VkMemoryOverallocationBehaviorAMD    overallocationBehavior;
10567 } VkDeviceMemoryOverallocationCreateInfoAMD;
10568 
10569 
10570 
10571 #define VK_EXT_vertex_attribute_divisor 1
10572 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3
10573 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"
10574 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
10575     VkStructureType    sType;
10576     void*              pNext;
10577     uint32_t           maxVertexAttribDivisor;
10578 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
10579 
10580 typedef struct VkVertexInputBindingDivisorDescriptionEXT {
10581     uint32_t    binding;
10582     uint32_t    divisor;
10583 } VkVertexInputBindingDivisorDescriptionEXT;
10584 
10585 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
10586     VkStructureType                                     sType;
10587     const void*                                         pNext;
10588     uint32_t                                            vertexBindingDivisorCount;
10589     const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors;
10590 } VkPipelineVertexInputDivisorStateCreateInfoEXT;
10591 
10592 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
10593     VkStructureType    sType;
10594     void*              pNext;
10595     VkBool32           vertexAttributeInstanceRateDivisor;
10596     VkBool32           vertexAttributeInstanceRateZeroDivisor;
10597 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
10598 
10599 
10600 
10601 #define VK_EXT_pipeline_creation_feedback 1
10602 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1
10603 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback"
10604 
10605 typedef enum VkPipelineCreationFeedbackFlagBitsEXT {
10606     VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 0x00000001,
10607     VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 0x00000002,
10608     VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 0x00000004,
10609     VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
10610 } VkPipelineCreationFeedbackFlagBitsEXT;
10611 typedef VkFlags VkPipelineCreationFeedbackFlagsEXT;
10612 typedef struct VkPipelineCreationFeedbackEXT {
10613     VkPipelineCreationFeedbackFlagsEXT    flags;
10614     uint64_t                              duration;
10615 } VkPipelineCreationFeedbackEXT;
10616 
10617 typedef struct VkPipelineCreationFeedbackCreateInfoEXT {
10618     VkStructureType                   sType;
10619     const void*                       pNext;
10620     VkPipelineCreationFeedbackEXT*    pPipelineCreationFeedback;
10621     uint32_t                          pipelineStageCreationFeedbackCount;
10622     VkPipelineCreationFeedbackEXT*    pPipelineStageCreationFeedbacks;
10623 } VkPipelineCreationFeedbackCreateInfoEXT;
10624 
10625 
10626 
10627 #define VK_NV_shader_subgroup_partitioned 1
10628 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
10629 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"
10630 
10631 
10632 #define VK_NV_compute_shader_derivatives 1
10633 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1
10634 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"
10635 typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
10636     VkStructureType    sType;
10637     void*              pNext;
10638     VkBool32           computeDerivativeGroupQuads;
10639     VkBool32           computeDerivativeGroupLinear;
10640 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
10641 
10642 
10643 
10644 #define VK_NV_mesh_shader 1
10645 #define VK_NV_MESH_SHADER_SPEC_VERSION    1
10646 #define VK_NV_MESH_SHADER_EXTENSION_NAME  "VK_NV_mesh_shader"
10647 typedef struct VkPhysicalDeviceMeshShaderFeaturesNV {
10648     VkStructureType    sType;
10649     void*              pNext;
10650     VkBool32           taskShader;
10651     VkBool32           meshShader;
10652 } VkPhysicalDeviceMeshShaderFeaturesNV;
10653 
10654 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV {
10655     VkStructureType    sType;
10656     void*              pNext;
10657     uint32_t           maxDrawMeshTasksCount;
10658     uint32_t           maxTaskWorkGroupInvocations;
10659     uint32_t           maxTaskWorkGroupSize[3];
10660     uint32_t           maxTaskTotalMemorySize;
10661     uint32_t           maxTaskOutputCount;
10662     uint32_t           maxMeshWorkGroupInvocations;
10663     uint32_t           maxMeshWorkGroupSize[3];
10664     uint32_t           maxMeshTotalMemorySize;
10665     uint32_t           maxMeshOutputVertices;
10666     uint32_t           maxMeshOutputPrimitives;
10667     uint32_t           maxMeshMultiviewViewCount;
10668     uint32_t           meshOutputPerVertexGranularity;
10669     uint32_t           meshOutputPerPrimitiveGranularity;
10670 } VkPhysicalDeviceMeshShaderPropertiesNV;
10671 
10672 typedef struct VkDrawMeshTasksIndirectCommandNV {
10673     uint32_t    taskCount;
10674     uint32_t    firstTask;
10675 } VkDrawMeshTasksIndirectCommandNV;
10676 
10677 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
10678 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
10679 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
10680 
10681 #ifndef VK_NO_PROTOTYPES
10682 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(
10683     VkCommandBuffer                             commandBuffer,
10684     uint32_t                                    taskCount,
10685     uint32_t                                    firstTask);
10686 
10687 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(
10688     VkCommandBuffer                             commandBuffer,
10689     VkBuffer                                    buffer,
10690     VkDeviceSize                                offset,
10691     uint32_t                                    drawCount,
10692     uint32_t                                    stride);
10693 
10694 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(
10695     VkCommandBuffer                             commandBuffer,
10696     VkBuffer                                    buffer,
10697     VkDeviceSize                                offset,
10698     VkBuffer                                    countBuffer,
10699     VkDeviceSize                                countBufferOffset,
10700     uint32_t                                    maxDrawCount,
10701     uint32_t                                    stride);
10702 #endif
10703 
10704 
10705 #define VK_NV_fragment_shader_barycentric 1
10706 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
10707 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"
10708 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
10709     VkStructureType    sType;
10710     void*              pNext;
10711     VkBool32           fragmentShaderBarycentric;
10712 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
10713 
10714 
10715 
10716 #define VK_NV_shader_image_footprint 1
10717 #define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2
10718 #define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
10719 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
10720     VkStructureType    sType;
10721     void*              pNext;
10722     VkBool32           imageFootprint;
10723 } VkPhysicalDeviceShaderImageFootprintFeaturesNV;
10724 
10725 
10726 
10727 #define VK_NV_scissor_exclusive 1
10728 #define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
10729 #define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"
10730 typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
10731     VkStructureType    sType;
10732     const void*        pNext;
10733     uint32_t           exclusiveScissorCount;
10734     const VkRect2D*    pExclusiveScissors;
10735 } VkPipelineViewportExclusiveScissorStateCreateInfoNV;
10736 
10737 typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
10738     VkStructureType    sType;
10739     void*              pNext;
10740     VkBool32           exclusiveScissor;
10741 } VkPhysicalDeviceExclusiveScissorFeaturesNV;
10742 
10743 typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
10744 
10745 #ifndef VK_NO_PROTOTYPES
10746 VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(
10747     VkCommandBuffer                             commandBuffer,
10748     uint32_t                                    firstExclusiveScissor,
10749     uint32_t                                    exclusiveScissorCount,
10750     const VkRect2D*                             pExclusiveScissors);
10751 #endif
10752 
10753 
10754 #define VK_NV_device_diagnostic_checkpoints 1
10755 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2
10756 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"
10757 typedef struct VkQueueFamilyCheckpointPropertiesNV {
10758     VkStructureType         sType;
10759     void*                   pNext;
10760     VkPipelineStageFlags    checkpointExecutionStageMask;
10761 } VkQueueFamilyCheckpointPropertiesNV;
10762 
10763 typedef struct VkCheckpointDataNV {
10764     VkStructureType            sType;
10765     void*                      pNext;
10766     VkPipelineStageFlagBits    stage;
10767     void*                      pCheckpointMarker;
10768 } VkCheckpointDataNV;
10769 
10770 typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker);
10771 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData);
10772 
10773 #ifndef VK_NO_PROTOTYPES
10774 VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(
10775     VkCommandBuffer                             commandBuffer,
10776     const void*                                 pCheckpointMarker);
10777 
10778 VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(
10779     VkQueue                                     queue,
10780     uint32_t*                                   pCheckpointDataCount,
10781     VkCheckpointDataNV*                         pCheckpointData);
10782 #endif
10783 
10784 
10785 #define VK_INTEL_shader_integer_functions2 1
10786 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1
10787 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
10788 typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
10789     VkStructureType    sType;
10790     void*              pNext;
10791     VkBool32           shaderIntegerFunctions2;
10792 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
10793 
10794 
10795 
10796 #define VK_INTEL_performance_query 1
10797 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)
10798 #define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 2
10799 #define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query"
10800 
10801 typedef enum VkPerformanceConfigurationTypeINTEL {
10802     VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0,
10803     VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
10804 } VkPerformanceConfigurationTypeINTEL;
10805 
10806 typedef enum VkQueryPoolSamplingModeINTEL {
10807     VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0,
10808     VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF
10809 } VkQueryPoolSamplingModeINTEL;
10810 
10811 typedef enum VkPerformanceOverrideTypeINTEL {
10812     VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0,
10813     VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1,
10814     VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
10815 } VkPerformanceOverrideTypeINTEL;
10816 
10817 typedef enum VkPerformanceParameterTypeINTEL {
10818     VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0,
10819     VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1,
10820     VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
10821 } VkPerformanceParameterTypeINTEL;
10822 
10823 typedef enum VkPerformanceValueTypeINTEL {
10824     VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,
10825     VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,
10826     VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2,
10827     VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3,
10828     VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,
10829     VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
10830 } VkPerformanceValueTypeINTEL;
10831 typedef union VkPerformanceValueDataINTEL {
10832     uint32_t       value32;
10833     uint64_t       value64;
10834     float          valueFloat;
10835     VkBool32       valueBool;
10836     const char*    valueString;
10837 } VkPerformanceValueDataINTEL;
10838 
10839 typedef struct VkPerformanceValueINTEL {
10840     VkPerformanceValueTypeINTEL    type;
10841     VkPerformanceValueDataINTEL    data;
10842 } VkPerformanceValueINTEL;
10843 
10844 typedef struct VkInitializePerformanceApiInfoINTEL {
10845     VkStructureType    sType;
10846     const void*        pNext;
10847     void*              pUserData;
10848 } VkInitializePerformanceApiInfoINTEL;
10849 
10850 typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL {
10851     VkStructureType                 sType;
10852     const void*                     pNext;
10853     VkQueryPoolSamplingModeINTEL    performanceCountersSampling;
10854 } VkQueryPoolPerformanceQueryCreateInfoINTEL;
10855 
10856 typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL;
10857 
10858 typedef struct VkPerformanceMarkerInfoINTEL {
10859     VkStructureType    sType;
10860     const void*        pNext;
10861     uint64_t           marker;
10862 } VkPerformanceMarkerInfoINTEL;
10863 
10864 typedef struct VkPerformanceStreamMarkerInfoINTEL {
10865     VkStructureType    sType;
10866     const void*        pNext;
10867     uint32_t           marker;
10868 } VkPerformanceStreamMarkerInfoINTEL;
10869 
10870 typedef struct VkPerformanceOverrideInfoINTEL {
10871     VkStructureType                   sType;
10872     const void*                       pNext;
10873     VkPerformanceOverrideTypeINTEL    type;
10874     VkBool32                          enable;
10875     uint64_t                          parameter;
10876 } VkPerformanceOverrideInfoINTEL;
10877 
10878 typedef struct VkPerformanceConfigurationAcquireInfoINTEL {
10879     VkStructureType                        sType;
10880     const void*                            pNext;
10881     VkPerformanceConfigurationTypeINTEL    type;
10882 } VkPerformanceConfigurationAcquireInfoINTEL;
10883 
10884 typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
10885 typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device);
10886 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
10887 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
10888 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
10889 typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration);
10890 typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration);
10891 typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration);
10892 typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue);
10893 
10894 #ifndef VK_NO_PROTOTYPES
10895 VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(
10896     VkDevice                                    device,
10897     const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);
10898 
10899 VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(
10900     VkDevice                                    device);
10901 
10902 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(
10903     VkCommandBuffer                             commandBuffer,
10904     const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);
10905 
10906 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(
10907     VkCommandBuffer                             commandBuffer,
10908     const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);
10909 
10910 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(
10911     VkCommandBuffer                             commandBuffer,
10912     const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);
10913 
10914 VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(
10915     VkDevice                                    device,
10916     const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
10917     VkPerformanceConfigurationINTEL*            pConfiguration);
10918 
10919 VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(
10920     VkDevice                                    device,
10921     VkPerformanceConfigurationINTEL             configuration);
10922 
10923 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(
10924     VkQueue                                     queue,
10925     VkPerformanceConfigurationINTEL             configuration);
10926 
10927 VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(
10928     VkDevice                                    device,
10929     VkPerformanceParameterTypeINTEL             parameter,
10930     VkPerformanceValueINTEL*                    pValue);
10931 #endif
10932 
10933 
10934 #define VK_EXT_pci_bus_info 1
10935 #define VK_EXT_PCI_BUS_INFO_SPEC_VERSION  2
10936 #define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info"
10937 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
10938     VkStructureType    sType;
10939     void*              pNext;
10940     uint32_t           pciDomain;
10941     uint32_t           pciBus;
10942     uint32_t           pciDevice;
10943     uint32_t           pciFunction;
10944 } VkPhysicalDevicePCIBusInfoPropertiesEXT;
10945 
10946 
10947 
10948 #define VK_AMD_display_native_hdr 1
10949 #define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1
10950 #define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr"
10951 typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
10952     VkStructureType    sType;
10953     void*              pNext;
10954     VkBool32           localDimmingSupport;
10955 } VkDisplayNativeHdrSurfaceCapabilitiesAMD;
10956 
10957 typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
10958     VkStructureType    sType;
10959     const void*        pNext;
10960     VkBool32           localDimmingEnable;
10961 } VkSwapchainDisplayNativeHdrCreateInfoAMD;
10962 
10963 typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable);
10964 
10965 #ifndef VK_NO_PROTOTYPES
10966 VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(
10967     VkDevice                                    device,
10968     VkSwapchainKHR                              swapChain,
10969     VkBool32                                    localDimmingEnable);
10970 #endif
10971 
10972 
10973 #define VK_EXT_fragment_density_map 1
10974 #define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 1
10975 #define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map"
10976 typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
10977     VkStructureType    sType;
10978     void*              pNext;
10979     VkBool32           fragmentDensityMap;
10980     VkBool32           fragmentDensityMapDynamic;
10981     VkBool32           fragmentDensityMapNonSubsampledImages;
10982 } VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
10983 
10984 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
10985     VkStructureType    sType;
10986     void*              pNext;
10987     VkExtent2D         minFragmentDensityTexelSize;
10988     VkExtent2D         maxFragmentDensityTexelSize;
10989     VkBool32           fragmentDensityInvocations;
10990 } VkPhysicalDeviceFragmentDensityMapPropertiesEXT;
10991 
10992 typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT {
10993     VkStructureType          sType;
10994     const void*              pNext;
10995     VkAttachmentReference    fragmentDensityMapAttachment;
10996 } VkRenderPassFragmentDensityMapCreateInfoEXT;
10997 
10998 
10999 
11000 #define VK_EXT_scalar_block_layout 1
11001 #define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1
11002 #define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout"
11003 typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;
11004 
11005 
11006 
11007 #define VK_GOOGLE_hlsl_functionality1 1
11008 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 1
11009 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1"
11010 
11011 
11012 #define VK_GOOGLE_decorate_string 1
11013 #define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1
11014 #define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"
11015 
11016 
11017 #define VK_EXT_subgroup_size_control 1
11018 #define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2
11019 #define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"
11020 typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
11021     VkStructureType    sType;
11022     void*              pNext;
11023     VkBool32           subgroupSizeControl;
11024     VkBool32           computeFullSubgroups;
11025 } VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;
11026 
11027 typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
11028     VkStructureType       sType;
11029     void*                 pNext;
11030     uint32_t              minSubgroupSize;
11031     uint32_t              maxSubgroupSize;
11032     uint32_t              maxComputeWorkgroupSubgroups;
11033     VkShaderStageFlags    requiredSubgroupSizeStages;
11034 } VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
11035 
11036 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
11037     VkStructureType    sType;
11038     void*              pNext;
11039     uint32_t           requiredSubgroupSize;
11040 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
11041 
11042 
11043 
11044 #define VK_AMD_shader_core_properties2 1
11045 #define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1
11046 #define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2"
11047 
11048 typedef enum VkShaderCorePropertiesFlagBitsAMD {
11049     VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
11050 } VkShaderCorePropertiesFlagBitsAMD;
11051 typedef VkFlags VkShaderCorePropertiesFlagsAMD;
11052 typedef struct VkPhysicalDeviceShaderCoreProperties2AMD {
11053     VkStructureType                   sType;
11054     void*                             pNext;
11055     VkShaderCorePropertiesFlagsAMD    shaderCoreFeatures;
11056     uint32_t                          activeComputeUnitCount;
11057 } VkPhysicalDeviceShaderCoreProperties2AMD;
11058 
11059 
11060 
11061 #define VK_AMD_device_coherent_memory 1
11062 #define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1
11063 #define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory"
11064 typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
11065     VkStructureType    sType;
11066     void*              pNext;
11067     VkBool32           deviceCoherentMemory;
11068 } VkPhysicalDeviceCoherentMemoryFeaturesAMD;
11069 
11070 
11071 
11072 #define VK_EXT_shader_image_atomic_int64 1
11073 #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1
11074 #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64"
11075 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
11076     VkStructureType    sType;
11077     void*              pNext;
11078     VkBool32           shaderImageInt64Atomics;
11079     VkBool32           sparseImageInt64Atomics;
11080 } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
11081 
11082 
11083 
11084 #define VK_EXT_memory_budget 1
11085 #define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1
11086 #define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"
11087 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
11088     VkStructureType    sType;
11089     void*              pNext;
11090     VkDeviceSize       heapBudget[VK_MAX_MEMORY_HEAPS];
11091     VkDeviceSize       heapUsage[VK_MAX_MEMORY_HEAPS];
11092 } VkPhysicalDeviceMemoryBudgetPropertiesEXT;
11093 
11094 
11095 
11096 #define VK_EXT_memory_priority 1
11097 #define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1
11098 #define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority"
11099 typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
11100     VkStructureType    sType;
11101     void*              pNext;
11102     VkBool32           memoryPriority;
11103 } VkPhysicalDeviceMemoryPriorityFeaturesEXT;
11104 
11105 typedef struct VkMemoryPriorityAllocateInfoEXT {
11106     VkStructureType    sType;
11107     const void*        pNext;
11108     float              priority;
11109 } VkMemoryPriorityAllocateInfoEXT;
11110 
11111 
11112 
11113 #define VK_NV_dedicated_allocation_image_aliasing 1
11114 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1
11115 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing"
11116 typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
11117     VkStructureType    sType;
11118     void*              pNext;
11119     VkBool32           dedicatedAllocationImageAliasing;
11120 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
11121 
11122 
11123 
11124 #define VK_EXT_buffer_device_address 1
11125 #define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2
11126 #define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
11127 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
11128     VkStructureType    sType;
11129     void*              pNext;
11130     VkBool32           bufferDeviceAddress;
11131     VkBool32           bufferDeviceAddressCaptureReplay;
11132     VkBool32           bufferDeviceAddressMultiDevice;
11133 } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
11134 
11135 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;
11136 
11137 typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT;
11138 
11139 typedef struct VkBufferDeviceAddressCreateInfoEXT {
11140     VkStructureType    sType;
11141     const void*        pNext;
11142     VkDeviceAddress    deviceAddress;
11143 } VkBufferDeviceAddressCreateInfoEXT;
11144 
11145 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
11146 
11147 #ifndef VK_NO_PROTOTYPES
11148 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(
11149     VkDevice                                    device,
11150     const VkBufferDeviceAddressInfo*            pInfo);
11151 #endif
11152 
11153 
11154 #define VK_EXT_tooling_info 1
11155 #define VK_EXT_TOOLING_INFO_SPEC_VERSION  1
11156 #define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info"
11157 
11158 typedef enum VkToolPurposeFlagBitsEXT {
11159     VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 0x00000001,
11160     VK_TOOL_PURPOSE_PROFILING_BIT_EXT = 0x00000002,
11161     VK_TOOL_PURPOSE_TRACING_BIT_EXT = 0x00000004,
11162     VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 0x00000008,
11163     VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 0x00000010,
11164     VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020,
11165     VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040,
11166     VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
11167 } VkToolPurposeFlagBitsEXT;
11168 typedef VkFlags VkToolPurposeFlagsEXT;
11169 typedef struct VkPhysicalDeviceToolPropertiesEXT {
11170     VkStructureType          sType;
11171     void*                    pNext;
11172     char                     name[VK_MAX_EXTENSION_NAME_SIZE];
11173     char                     version[VK_MAX_EXTENSION_NAME_SIZE];
11174     VkToolPurposeFlagsEXT    purposes;
11175     char                     description[VK_MAX_DESCRIPTION_SIZE];
11176     char                     layer[VK_MAX_EXTENSION_NAME_SIZE];
11177 } VkPhysicalDeviceToolPropertiesEXT;
11178 
11179 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolPropertiesEXT* pToolProperties);
11180 
11181 #ifndef VK_NO_PROTOTYPES
11182 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(
11183     VkPhysicalDevice                            physicalDevice,
11184     uint32_t*                                   pToolCount,
11185     VkPhysicalDeviceToolPropertiesEXT*          pToolProperties);
11186 #endif
11187 
11188 
11189 #define VK_EXT_separate_stencil_usage 1
11190 #define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1
11191 #define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage"
11192 typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT;
11193 
11194 
11195 
11196 #define VK_EXT_validation_features 1
11197 #define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5
11198 #define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"
11199 
11200 typedef enum VkValidationFeatureEnableEXT {
11201     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
11202     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
11203     VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2,
11204     VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3,
11205     VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4,
11206     VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF
11207 } VkValidationFeatureEnableEXT;
11208 
11209 typedef enum VkValidationFeatureDisableEXT {
11210     VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,
11211     VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,
11212     VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,
11213     VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,
11214     VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,
11215     VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,
11216     VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,
11217     VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7,
11218     VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF
11219 } VkValidationFeatureDisableEXT;
11220 typedef struct VkValidationFeaturesEXT {
11221     VkStructureType                         sType;
11222     const void*                             pNext;
11223     uint32_t                                enabledValidationFeatureCount;
11224     const VkValidationFeatureEnableEXT*     pEnabledValidationFeatures;
11225     uint32_t                                disabledValidationFeatureCount;
11226     const VkValidationFeatureDisableEXT*    pDisabledValidationFeatures;
11227 } VkValidationFeaturesEXT;
11228 
11229 
11230 
11231 #define VK_NV_cooperative_matrix 1
11232 #define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1
11233 #define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix"
11234 
11235 typedef enum VkComponentTypeNV {
11236     VK_COMPONENT_TYPE_FLOAT16_NV = 0,
11237     VK_COMPONENT_TYPE_FLOAT32_NV = 1,
11238     VK_COMPONENT_TYPE_FLOAT64_NV = 2,
11239     VK_COMPONENT_TYPE_SINT8_NV = 3,
11240     VK_COMPONENT_TYPE_SINT16_NV = 4,
11241     VK_COMPONENT_TYPE_SINT32_NV = 5,
11242     VK_COMPONENT_TYPE_SINT64_NV = 6,
11243     VK_COMPONENT_TYPE_UINT8_NV = 7,
11244     VK_COMPONENT_TYPE_UINT16_NV = 8,
11245     VK_COMPONENT_TYPE_UINT32_NV = 9,
11246     VK_COMPONENT_TYPE_UINT64_NV = 10,
11247     VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
11248 } VkComponentTypeNV;
11249 
11250 typedef enum VkScopeNV {
11251     VK_SCOPE_DEVICE_NV = 1,
11252     VK_SCOPE_WORKGROUP_NV = 2,
11253     VK_SCOPE_SUBGROUP_NV = 3,
11254     VK_SCOPE_QUEUE_FAMILY_NV = 5,
11255     VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF
11256 } VkScopeNV;
11257 typedef struct VkCooperativeMatrixPropertiesNV {
11258     VkStructureType      sType;
11259     void*                pNext;
11260     uint32_t             MSize;
11261     uint32_t             NSize;
11262     uint32_t             KSize;
11263     VkComponentTypeNV    AType;
11264     VkComponentTypeNV    BType;
11265     VkComponentTypeNV    CType;
11266     VkComponentTypeNV    DType;
11267     VkScopeNV            scope;
11268 } VkCooperativeMatrixPropertiesNV;
11269 
11270 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
11271     VkStructureType    sType;
11272     void*              pNext;
11273     VkBool32           cooperativeMatrix;
11274     VkBool32           cooperativeMatrixRobustBufferAccess;
11275 } VkPhysicalDeviceCooperativeMatrixFeaturesNV;
11276 
11277 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
11278     VkStructureType       sType;
11279     void*                 pNext;
11280     VkShaderStageFlags    cooperativeMatrixSupportedStages;
11281 } VkPhysicalDeviceCooperativeMatrixPropertiesNV;
11282 
11283 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties);
11284 
11285 #ifndef VK_NO_PROTOTYPES
11286 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
11287     VkPhysicalDevice                            physicalDevice,
11288     uint32_t*                                   pPropertyCount,
11289     VkCooperativeMatrixPropertiesNV*            pProperties);
11290 #endif
11291 
11292 
11293 #define VK_NV_coverage_reduction_mode 1
11294 #define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1
11295 #define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode"
11296 
11297 typedef enum VkCoverageReductionModeNV {
11298     VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0,
11299     VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1,
11300     VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
11301 } VkCoverageReductionModeNV;
11302 typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;
11303 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
11304     VkStructureType    sType;
11305     void*              pNext;
11306     VkBool32           coverageReductionMode;
11307 } VkPhysicalDeviceCoverageReductionModeFeaturesNV;
11308 
11309 typedef struct VkPipelineCoverageReductionStateCreateInfoNV {
11310     VkStructureType                                  sType;
11311     const void*                                      pNext;
11312     VkPipelineCoverageReductionStateCreateFlagsNV    flags;
11313     VkCoverageReductionModeNV                        coverageReductionMode;
11314 } VkPipelineCoverageReductionStateCreateInfoNV;
11315 
11316 typedef struct VkFramebufferMixedSamplesCombinationNV {
11317     VkStructureType              sType;
11318     void*                        pNext;
11319     VkCoverageReductionModeNV    coverageReductionMode;
11320     VkSampleCountFlagBits        rasterizationSamples;
11321     VkSampleCountFlags           depthStencilSamples;
11322     VkSampleCountFlags           colorSamples;
11323 } VkFramebufferMixedSamplesCombinationNV;
11324 
11325 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations);
11326 
11327 #ifndef VK_NO_PROTOTYPES
11328 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
11329     VkPhysicalDevice                            physicalDevice,
11330     uint32_t*                                   pCombinationCount,
11331     VkFramebufferMixedSamplesCombinationNV*     pCombinations);
11332 #endif
11333 
11334 
11335 #define VK_EXT_fragment_shader_interlock 1
11336 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1
11337 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock"
11338 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
11339     VkStructureType    sType;
11340     void*              pNext;
11341     VkBool32           fragmentShaderSampleInterlock;
11342     VkBool32           fragmentShaderPixelInterlock;
11343     VkBool32           fragmentShaderShadingRateInterlock;
11344 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
11345 
11346 
11347 
11348 #define VK_EXT_ycbcr_image_arrays 1
11349 #define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1
11350 #define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
11351 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
11352     VkStructureType    sType;
11353     void*              pNext;
11354     VkBool32           ycbcrImageArrays;
11355 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
11356 
11357 
11358 
11359 #define VK_EXT_provoking_vertex 1
11360 #define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1
11361 #define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex"
11362 
11363 typedef enum VkProvokingVertexModeEXT {
11364     VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0,
11365     VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1,
11366     VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
11367 } VkProvokingVertexModeEXT;
11368 typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
11369     VkStructureType    sType;
11370     void*              pNext;
11371     VkBool32           provokingVertexLast;
11372     VkBool32           transformFeedbackPreservesProvokingVertex;
11373 } VkPhysicalDeviceProvokingVertexFeaturesEXT;
11374 
11375 typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
11376     VkStructureType    sType;
11377     void*              pNext;
11378     VkBool32           provokingVertexModePerPipeline;
11379     VkBool32           transformFeedbackPreservesTriangleFanProvokingVertex;
11380 } VkPhysicalDeviceProvokingVertexPropertiesEXT;
11381 
11382 typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
11383     VkStructureType             sType;
11384     const void*                 pNext;
11385     VkProvokingVertexModeEXT    provokingVertexMode;
11386 } VkPipelineRasterizationProvokingVertexStateCreateInfoEXT;
11387 
11388 
11389 
11390 #define VK_EXT_headless_surface 1
11391 #define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1
11392 #define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface"
11393 typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
11394 typedef struct VkHeadlessSurfaceCreateInfoEXT {
11395     VkStructureType                    sType;
11396     const void*                        pNext;
11397     VkHeadlessSurfaceCreateFlagsEXT    flags;
11398 } VkHeadlessSurfaceCreateInfoEXT;
11399 
11400 typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
11401 
11402 #ifndef VK_NO_PROTOTYPES
11403 VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(
11404     VkInstance                                  instance,
11405     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
11406     const VkAllocationCallbacks*                pAllocator,
11407     VkSurfaceKHR*                               pSurface);
11408 #endif
11409 
11410 
11411 #define VK_EXT_line_rasterization 1
11412 #define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
11413 #define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
11414 
11415 typedef enum VkLineRasterizationModeEXT {
11416     VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
11417     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
11418     VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
11419     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
11420     VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
11421 } VkLineRasterizationModeEXT;
11422 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
11423     VkStructureType    sType;
11424     void*              pNext;
11425     VkBool32           rectangularLines;
11426     VkBool32           bresenhamLines;
11427     VkBool32           smoothLines;
11428     VkBool32           stippledRectangularLines;
11429     VkBool32           stippledBresenhamLines;
11430     VkBool32           stippledSmoothLines;
11431 } VkPhysicalDeviceLineRasterizationFeaturesEXT;
11432 
11433 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
11434     VkStructureType    sType;
11435     void*              pNext;
11436     uint32_t           lineSubPixelPrecisionBits;
11437 } VkPhysicalDeviceLineRasterizationPropertiesEXT;
11438 
11439 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
11440     VkStructureType               sType;
11441     const void*                   pNext;
11442     VkLineRasterizationModeEXT    lineRasterizationMode;
11443     VkBool32                      stippledLineEnable;
11444     uint32_t                      lineStippleFactor;
11445     uint16_t                      lineStipplePattern;
11446 } VkPipelineRasterizationLineStateCreateInfoEXT;
11447 
11448 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
11449 
11450 #ifndef VK_NO_PROTOTYPES
11451 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(
11452     VkCommandBuffer                             commandBuffer,
11453     uint32_t                                    lineStippleFactor,
11454     uint16_t                                    lineStipplePattern);
11455 #endif
11456 
11457 
11458 #define VK_EXT_shader_atomic_float 1
11459 #define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1
11460 #define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float"
11461 typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
11462     VkStructureType    sType;
11463     void*              pNext;
11464     VkBool32           shaderBufferFloat32Atomics;
11465     VkBool32           shaderBufferFloat32AtomicAdd;
11466     VkBool32           shaderBufferFloat64Atomics;
11467     VkBool32           shaderBufferFloat64AtomicAdd;
11468     VkBool32           shaderSharedFloat32Atomics;
11469     VkBool32           shaderSharedFloat32AtomicAdd;
11470     VkBool32           shaderSharedFloat64Atomics;
11471     VkBool32           shaderSharedFloat64AtomicAdd;
11472     VkBool32           shaderImageFloat32Atomics;
11473     VkBool32           shaderImageFloat32AtomicAdd;
11474     VkBool32           sparseImageFloat32Atomics;
11475     VkBool32           sparseImageFloat32AtomicAdd;
11476 } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
11477 
11478 
11479 
11480 #define VK_EXT_host_query_reset 1
11481 #define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1
11482 #define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset"
11483 typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT;
11484 
11485 typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
11486 
11487 #ifndef VK_NO_PROTOTYPES
11488 VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(
11489     VkDevice                                    device,
11490     VkQueryPool                                 queryPool,
11491     uint32_t                                    firstQuery,
11492     uint32_t                                    queryCount);
11493 #endif
11494 
11495 
11496 #define VK_EXT_index_type_uint8 1
11497 #define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
11498 #define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
11499 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
11500     VkStructureType    sType;
11501     void*              pNext;
11502     VkBool32           indexTypeUint8;
11503 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
11504 
11505 
11506 
11507 #define VK_EXT_extended_dynamic_state 1
11508 #define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1
11509 #define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state"
11510 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
11511     VkStructureType    sType;
11512     void*              pNext;
11513     VkBool32           extendedDynamicState;
11514 } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT;
11515 
11516 typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
11517 typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
11518 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
11519 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
11520 typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
11521 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);
11522 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);
11523 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);
11524 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
11525 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
11526 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
11527 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
11528 
11529 #ifndef VK_NO_PROTOTYPES
11530 VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(
11531     VkCommandBuffer                             commandBuffer,
11532     VkCullModeFlags                             cullMode);
11533 
11534 VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(
11535     VkCommandBuffer                             commandBuffer,
11536     VkFrontFace                                 frontFace);
11537 
11538 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(
11539     VkCommandBuffer                             commandBuffer,
11540     VkPrimitiveTopology                         primitiveTopology);
11541 
11542 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(
11543     VkCommandBuffer                             commandBuffer,
11544     uint32_t                                    viewportCount,
11545     const VkViewport*                           pViewports);
11546 
11547 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(
11548     VkCommandBuffer                             commandBuffer,
11549     uint32_t                                    scissorCount,
11550     const VkRect2D*                             pScissors);
11551 
11552 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(
11553     VkCommandBuffer                             commandBuffer,
11554     uint32_t                                    firstBinding,
11555     uint32_t                                    bindingCount,
11556     const VkBuffer*                             pBuffers,
11557     const VkDeviceSize*                         pOffsets,
11558     const VkDeviceSize*                         pSizes,
11559     const VkDeviceSize*                         pStrides);
11560 
11561 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(
11562     VkCommandBuffer                             commandBuffer,
11563     VkBool32                                    depthTestEnable);
11564 
11565 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(
11566     VkCommandBuffer                             commandBuffer,
11567     VkBool32                                    depthWriteEnable);
11568 
11569 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(
11570     VkCommandBuffer                             commandBuffer,
11571     VkCompareOp                                 depthCompareOp);
11572 
11573 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(
11574     VkCommandBuffer                             commandBuffer,
11575     VkBool32                                    depthBoundsTestEnable);
11576 
11577 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(
11578     VkCommandBuffer                             commandBuffer,
11579     VkBool32                                    stencilTestEnable);
11580 
11581 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(
11582     VkCommandBuffer                             commandBuffer,
11583     VkStencilFaceFlags                          faceMask,
11584     VkStencilOp                                 failOp,
11585     VkStencilOp                                 passOp,
11586     VkStencilOp                                 depthFailOp,
11587     VkCompareOp                                 compareOp);
11588 #endif
11589 
11590 
11591 #define VK_EXT_shader_demote_to_helper_invocation 1
11592 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1
11593 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"
11594 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
11595     VkStructureType    sType;
11596     void*              pNext;
11597     VkBool32           shaderDemoteToHelperInvocation;
11598 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
11599 
11600 
11601 
11602 #define VK_NV_device_generated_commands 1
11603 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV)
11604 #define VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
11605 #define VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NV_device_generated_commands"
11606 
11607 typedef enum VkIndirectCommandsTokenTypeNV {
11608     VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0,
11609     VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1,
11610     VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2,
11611     VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3,
11612     VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4,
11613     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5,
11614     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6,
11615     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7,
11616     VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
11617 } VkIndirectCommandsTokenTypeNV;
11618 
11619 typedef enum VkIndirectStateFlagBitsNV {
11620     VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001,
11621     VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
11622 } VkIndirectStateFlagBitsNV;
11623 typedef VkFlags VkIndirectStateFlagsNV;
11624 
11625 typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV {
11626     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001,
11627     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002,
11628     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004,
11629     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
11630 } VkIndirectCommandsLayoutUsageFlagBitsNV;
11631 typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV;
11632 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
11633     VkStructureType    sType;
11634     void*              pNext;
11635     uint32_t           maxGraphicsShaderGroupCount;
11636     uint32_t           maxIndirectSequenceCount;
11637     uint32_t           maxIndirectCommandsTokenCount;
11638     uint32_t           maxIndirectCommandsStreamCount;
11639     uint32_t           maxIndirectCommandsTokenOffset;
11640     uint32_t           maxIndirectCommandsStreamStride;
11641     uint32_t           minSequencesCountBufferOffsetAlignment;
11642     uint32_t           minSequencesIndexBufferOffsetAlignment;
11643     uint32_t           minIndirectCommandsBufferOffsetAlignment;
11644 } VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
11645 
11646 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
11647     VkStructureType    sType;
11648     void*              pNext;
11649     VkBool32           deviceGeneratedCommands;
11650 } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
11651 
11652 typedef struct VkGraphicsShaderGroupCreateInfoNV {
11653     VkStructureType                                 sType;
11654     const void*                                     pNext;
11655     uint32_t                                        stageCount;
11656     const VkPipelineShaderStageCreateInfo*          pStages;
11657     const VkPipelineVertexInputStateCreateInfo*     pVertexInputState;
11658     const VkPipelineTessellationStateCreateInfo*    pTessellationState;
11659 } VkGraphicsShaderGroupCreateInfoNV;
11660 
11661 typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV {
11662     VkStructureType                             sType;
11663     const void*                                 pNext;
11664     uint32_t                                    groupCount;
11665     const VkGraphicsShaderGroupCreateInfoNV*    pGroups;
11666     uint32_t                                    pipelineCount;
11667     const VkPipeline*                           pPipelines;
11668 } VkGraphicsPipelineShaderGroupsCreateInfoNV;
11669 
11670 typedef struct VkBindShaderGroupIndirectCommandNV {
11671     uint32_t    groupIndex;
11672 } VkBindShaderGroupIndirectCommandNV;
11673 
11674 typedef struct VkBindIndexBufferIndirectCommandNV {
11675     VkDeviceAddress    bufferAddress;
11676     uint32_t           size;
11677     VkIndexType        indexType;
11678 } VkBindIndexBufferIndirectCommandNV;
11679 
11680 typedef struct VkBindVertexBufferIndirectCommandNV {
11681     VkDeviceAddress    bufferAddress;
11682     uint32_t           size;
11683     uint32_t           stride;
11684 } VkBindVertexBufferIndirectCommandNV;
11685 
11686 typedef struct VkSetStateFlagsIndirectCommandNV {
11687     uint32_t    data;
11688 } VkSetStateFlagsIndirectCommandNV;
11689 
11690 typedef struct VkIndirectCommandsStreamNV {
11691     VkBuffer        buffer;
11692     VkDeviceSize    offset;
11693 } VkIndirectCommandsStreamNV;
11694 
11695 typedef struct VkIndirectCommandsLayoutTokenNV {
11696     VkStructureType                  sType;
11697     const void*                      pNext;
11698     VkIndirectCommandsTokenTypeNV    tokenType;
11699     uint32_t                         stream;
11700     uint32_t                         offset;
11701     uint32_t                         vertexBindingUnit;
11702     VkBool32                         vertexDynamicStride;
11703     VkPipelineLayout                 pushconstantPipelineLayout;
11704     VkShaderStageFlags               pushconstantShaderStageFlags;
11705     uint32_t                         pushconstantOffset;
11706     uint32_t                         pushconstantSize;
11707     VkIndirectStateFlagsNV           indirectStateFlags;
11708     uint32_t                         indexTypeCount;
11709     const VkIndexType*               pIndexTypes;
11710     const uint32_t*                  pIndexTypeValues;
11711 } VkIndirectCommandsLayoutTokenNV;
11712 
11713 typedef struct VkIndirectCommandsLayoutCreateInfoNV {
11714     VkStructureType                           sType;
11715     const void*                               pNext;
11716     VkIndirectCommandsLayoutUsageFlagsNV      flags;
11717     VkPipelineBindPoint                       pipelineBindPoint;
11718     uint32_t                                  tokenCount;
11719     const VkIndirectCommandsLayoutTokenNV*    pTokens;
11720     uint32_t                                  streamCount;
11721     const uint32_t*                           pStreamStrides;
11722 } VkIndirectCommandsLayoutCreateInfoNV;
11723 
11724 typedef struct VkGeneratedCommandsInfoNV {
11725     VkStructureType                      sType;
11726     const void*                          pNext;
11727     VkPipelineBindPoint                  pipelineBindPoint;
11728     VkPipeline                           pipeline;
11729     VkIndirectCommandsLayoutNV           indirectCommandsLayout;
11730     uint32_t                             streamCount;
11731     const VkIndirectCommandsStreamNV*    pStreams;
11732     uint32_t                             sequencesCount;
11733     VkBuffer                             preprocessBuffer;
11734     VkDeviceSize                         preprocessOffset;
11735     VkDeviceSize                         preprocessSize;
11736     VkBuffer                             sequencesCountBuffer;
11737     VkDeviceSize                         sequencesCountOffset;
11738     VkBuffer                             sequencesIndexBuffer;
11739     VkDeviceSize                         sequencesIndexOffset;
11740 } VkGeneratedCommandsInfoNV;
11741 
11742 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV {
11743     VkStructureType               sType;
11744     const void*                   pNext;
11745     VkPipelineBindPoint           pipelineBindPoint;
11746     VkPipeline                    pipeline;
11747     VkIndirectCommandsLayoutNV    indirectCommandsLayout;
11748     uint32_t                      maxSequencesCount;
11749 } VkGeneratedCommandsMemoryRequirementsInfoNV;
11750 
11751 typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements);
11752 typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
11753 typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
11754 typedef void (VKAPI_PTR *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex);
11755 typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);
11756 typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
11757 
11758 #ifndef VK_NO_PROTOTYPES
11759 VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(
11760     VkDevice                                    device,
11761     const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
11762     VkMemoryRequirements2*                      pMemoryRequirements);
11763 
11764 VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(
11765     VkCommandBuffer                             commandBuffer,
11766     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
11767 
11768 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(
11769     VkCommandBuffer                             commandBuffer,
11770     VkBool32                                    isPreprocessed,
11771     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
11772 
11773 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(
11774     VkCommandBuffer                             commandBuffer,
11775     VkPipelineBindPoint                         pipelineBindPoint,
11776     VkPipeline                                  pipeline,
11777     uint32_t                                    groupIndex);
11778 
11779 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(
11780     VkDevice                                    device,
11781     const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
11782     const VkAllocationCallbacks*                pAllocator,
11783     VkIndirectCommandsLayoutNV*                 pIndirectCommandsLayout);
11784 
11785 VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(
11786     VkDevice                                    device,
11787     VkIndirectCommandsLayoutNV                  indirectCommandsLayout,
11788     const VkAllocationCallbacks*                pAllocator);
11789 #endif
11790 
11791 
11792 #define VK_NV_inherited_viewport_scissor 1
11793 #define VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION 1
11794 #define VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME "VK_NV_inherited_viewport_scissor"
11795 typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
11796     VkStructureType    sType;
11797     void*              pNext;
11798     VkBool32           inheritedViewportScissor2D;
11799 } VkPhysicalDeviceInheritedViewportScissorFeaturesNV;
11800 
11801 typedef struct VkCommandBufferInheritanceViewportScissorInfoNV {
11802     VkStructureType      sType;
11803     const void*          pNext;
11804     VkBool32             viewportScissor2D;
11805     uint32_t             viewportDepthCount;
11806     const VkViewport*    pViewportDepths;
11807 } VkCommandBufferInheritanceViewportScissorInfoNV;
11808 
11809 
11810 
11811 #define VK_EXT_texel_buffer_alignment 1
11812 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1
11813 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment"
11814 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
11815     VkStructureType    sType;
11816     void*              pNext;
11817     VkBool32           texelBufferAlignment;
11818 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
11819 
11820 typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT {
11821     VkStructureType    sType;
11822     void*              pNext;
11823     VkDeviceSize       storageTexelBufferOffsetAlignmentBytes;
11824     VkBool32           storageTexelBufferOffsetSingleTexelAlignment;
11825     VkDeviceSize       uniformTexelBufferOffsetAlignmentBytes;
11826     VkBool32           uniformTexelBufferOffsetSingleTexelAlignment;
11827 } VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
11828 
11829 
11830 
11831 #define VK_QCOM_render_pass_transform 1
11832 #define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 2
11833 #define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform"
11834 typedef struct VkRenderPassTransformBeginInfoQCOM {
11835     VkStructureType                  sType;
11836     void*                            pNext;
11837     VkSurfaceTransformFlagBitsKHR    transform;
11838 } VkRenderPassTransformBeginInfoQCOM;
11839 
11840 typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
11841     VkStructureType                  sType;
11842     void*                            pNext;
11843     VkSurfaceTransformFlagBitsKHR    transform;
11844     VkRect2D                         renderArea;
11845 } VkCommandBufferInheritanceRenderPassTransformInfoQCOM;
11846 
11847 
11848 
11849 #define VK_EXT_device_memory_report 1
11850 #define VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION 2
11851 #define VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME "VK_EXT_device_memory_report"
11852 
11853 typedef enum VkDeviceMemoryReportEventTypeEXT {
11854     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0,
11855     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1,
11856     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2,
11857     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3,
11858     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4,
11859     VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
11860 } VkDeviceMemoryReportEventTypeEXT;
11861 typedef VkFlags VkDeviceMemoryReportFlagsEXT;
11862 typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
11863     VkStructureType    sType;
11864     void*              pNext;
11865     VkBool32           deviceMemoryReport;
11866 } VkPhysicalDeviceDeviceMemoryReportFeaturesEXT;
11867 
11868 typedef struct VkDeviceMemoryReportCallbackDataEXT {
11869     VkStructureType                     sType;
11870     const void*                         pNext;
11871     VkDeviceMemoryReportFlagsEXT        flags;
11872     VkDeviceMemoryReportEventTypeEXT    type;
11873     uint64_t                            memoryObjectId;
11874     VkDeviceSize                        size;
11875     VkObjectType                        objectType;
11876     uint64_t                            objectHandle;
11877     uint32_t                            heapIndex;
11878 } VkDeviceMemoryReportCallbackDataEXT;
11879 
11880 typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)(
11881     const VkDeviceMemoryReportCallbackDataEXT*  pCallbackData,
11882     void*                                       pUserData);
11883 
11884 typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT {
11885     VkStructureType                        sType;
11886     const void*                            pNext;
11887     VkDeviceMemoryReportFlagsEXT           flags;
11888     PFN_vkDeviceMemoryReportCallbackEXT    pfnUserCallback;
11889     void*                                  pUserData;
11890 } VkDeviceDeviceMemoryReportCreateInfoEXT;
11891 
11892 
11893 
11894 #define VK_EXT_acquire_drm_display 1
11895 #define VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION 1
11896 #define VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_drm_display"
11897 typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display);
11898 typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display);
11899 
11900 #ifndef VK_NO_PROTOTYPES
11901 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(
11902     VkPhysicalDevice                            physicalDevice,
11903     int32_t                                     drmFd,
11904     VkDisplayKHR                                display);
11905 
11906 VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(
11907     VkPhysicalDevice                            physicalDevice,
11908     int32_t                                     drmFd,
11909     uint32_t                                    connectorId,
11910     VkDisplayKHR*                               display);
11911 #endif
11912 
11913 
11914 #define VK_EXT_robustness2 1
11915 #define VK_EXT_ROBUSTNESS_2_SPEC_VERSION  1
11916 #define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2"
11917 typedef struct VkPhysicalDeviceRobustness2FeaturesEXT {
11918     VkStructureType    sType;
11919     void*              pNext;
11920     VkBool32           robustBufferAccess2;
11921     VkBool32           robustImageAccess2;
11922     VkBool32           nullDescriptor;
11923 } VkPhysicalDeviceRobustness2FeaturesEXT;
11924 
11925 typedef struct VkPhysicalDeviceRobustness2PropertiesEXT {
11926     VkStructureType    sType;
11927     void*              pNext;
11928     VkDeviceSize       robustStorageBufferAccessSizeAlignment;
11929     VkDeviceSize       robustUniformBufferAccessSizeAlignment;
11930 } VkPhysicalDeviceRobustness2PropertiesEXT;
11931 
11932 
11933 
11934 #define VK_EXT_custom_border_color 1
11935 #define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12
11936 #define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color"
11937 typedef struct VkSamplerCustomBorderColorCreateInfoEXT {
11938     VkStructureType      sType;
11939     const void*          pNext;
11940     VkClearColorValue    customBorderColor;
11941     VkFormat             format;
11942 } VkSamplerCustomBorderColorCreateInfoEXT;
11943 
11944 typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
11945     VkStructureType    sType;
11946     void*              pNext;
11947     uint32_t           maxCustomBorderColorSamplers;
11948 } VkPhysicalDeviceCustomBorderColorPropertiesEXT;
11949 
11950 typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
11951     VkStructureType    sType;
11952     void*              pNext;
11953     VkBool32           customBorderColors;
11954     VkBool32           customBorderColorWithoutFormat;
11955 } VkPhysicalDeviceCustomBorderColorFeaturesEXT;
11956 
11957 
11958 
11959 #define VK_GOOGLE_user_type 1
11960 #define VK_GOOGLE_USER_TYPE_SPEC_VERSION  1
11961 #define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type"
11962 
11963 
11964 #define VK_EXT_private_data 1
11965 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlotEXT)
11966 #define VK_EXT_PRIVATE_DATA_SPEC_VERSION  1
11967 #define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data"
11968 
11969 typedef enum VkPrivateDataSlotCreateFlagBitsEXT {
11970     VK_PRIVATE_DATA_SLOT_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
11971 } VkPrivateDataSlotCreateFlagBitsEXT;
11972 typedef VkFlags VkPrivateDataSlotCreateFlagsEXT;
11973 typedef struct VkPhysicalDevicePrivateDataFeaturesEXT {
11974     VkStructureType    sType;
11975     void*              pNext;
11976     VkBool32           privateData;
11977 } VkPhysicalDevicePrivateDataFeaturesEXT;
11978 
11979 typedef struct VkDevicePrivateDataCreateInfoEXT {
11980     VkStructureType    sType;
11981     const void*        pNext;
11982     uint32_t           privateDataSlotRequestCount;
11983 } VkDevicePrivateDataCreateInfoEXT;
11984 
11985 typedef struct VkPrivateDataSlotCreateInfoEXT {
11986     VkStructureType                    sType;
11987     const void*                        pNext;
11988     VkPrivateDataSlotCreateFlagsEXT    flags;
11989 } VkPrivateDataSlotCreateInfoEXT;
11990 
11991 typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot);
11992 typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks* pAllocator);
11993 typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data);
11994 typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData);
11995 
11996 #ifndef VK_NO_PROTOTYPES
11997 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(
11998     VkDevice                                    device,
11999     const VkPrivateDataSlotCreateInfoEXT*       pCreateInfo,
12000     const VkAllocationCallbacks*                pAllocator,
12001     VkPrivateDataSlotEXT*                       pPrivateDataSlot);
12002 
12003 VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(
12004     VkDevice                                    device,
12005     VkPrivateDataSlotEXT                        privateDataSlot,
12006     const VkAllocationCallbacks*                pAllocator);
12007 
12008 VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(
12009     VkDevice                                    device,
12010     VkObjectType                                objectType,
12011     uint64_t                                    objectHandle,
12012     VkPrivateDataSlotEXT                        privateDataSlot,
12013     uint64_t                                    data);
12014 
12015 VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(
12016     VkDevice                                    device,
12017     VkObjectType                                objectType,
12018     uint64_t                                    objectHandle,
12019     VkPrivateDataSlotEXT                        privateDataSlot,
12020     uint64_t*                                   pData);
12021 #endif
12022 
12023 
12024 #define VK_EXT_pipeline_creation_cache_control 1
12025 #define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION 3
12026 #define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME "VK_EXT_pipeline_creation_cache_control"
12027 typedef struct VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT {
12028     VkStructureType    sType;
12029     void*              pNext;
12030     VkBool32           pipelineCreationCacheControl;
12031 } VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT;
12032 
12033 
12034 
12035 #define VK_NV_device_diagnostics_config 1
12036 #define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 1
12037 #define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config"
12038 
12039 typedef enum VkDeviceDiagnosticsConfigFlagBitsNV {
12040     VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001,
12041     VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002,
12042     VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004,
12043     VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
12044 } VkDeviceDiagnosticsConfigFlagBitsNV;
12045 typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV;
12046 typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
12047     VkStructureType    sType;
12048     void*              pNext;
12049     VkBool32           diagnosticsConfig;
12050 } VkPhysicalDeviceDiagnosticsConfigFeaturesNV;
12051 
12052 typedef struct VkDeviceDiagnosticsConfigCreateInfoNV {
12053     VkStructureType                     sType;
12054     const void*                         pNext;
12055     VkDeviceDiagnosticsConfigFlagsNV    flags;
12056 } VkDeviceDiagnosticsConfigCreateInfoNV;
12057 
12058 
12059 
12060 #define VK_QCOM_render_pass_store_ops 1
12061 #define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2
12062 #define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops"
12063 
12064 
12065 #define VK_NV_fragment_shading_rate_enums 1
12066 #define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1
12067 #define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums"
12068 
12069 typedef enum VkFragmentShadingRateTypeNV {
12070     VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0,
12071     VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1,
12072     VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
12073 } VkFragmentShadingRateTypeNV;
12074 
12075 typedef enum VkFragmentShadingRateNV {
12076     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0,
12077     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1,
12078     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4,
12079     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5,
12080     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6,
12081     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
12082     VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10,
12083     VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11,
12084     VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12,
12085     VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13,
12086     VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14,
12087     VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15,
12088     VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF
12089 } VkFragmentShadingRateNV;
12090 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
12091     VkStructureType    sType;
12092     void*              pNext;
12093     VkBool32           fragmentShadingRateEnums;
12094     VkBool32           supersampleFragmentShadingRates;
12095     VkBool32           noInvocationFragmentShadingRates;
12096 } VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
12097 
12098 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
12099     VkStructureType          sType;
12100     void*                    pNext;
12101     VkSampleCountFlagBits    maxFragmentShadingRateInvocationCount;
12102 } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
12103 
12104 typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV {
12105     VkStructureType                       sType;
12106     const void*                           pNext;
12107     VkFragmentShadingRateTypeNV           shadingRateType;
12108     VkFragmentShadingRateNV               shadingRate;
12109     VkFragmentShadingRateCombinerOpKHR    combinerOps[2];
12110 } VkPipelineFragmentShadingRateEnumStateCreateInfoNV;
12111 
12112 typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer           commandBuffer, VkFragmentShadingRateNV                     shadingRate, const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
12113 
12114 #ifndef VK_NO_PROTOTYPES
12115 VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(
12116     VkCommandBuffer                             commandBuffer,
12117     VkFragmentShadingRateNV                     shadingRate,
12118     const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
12119 #endif
12120 
12121 
12122 #define VK_NV_ray_tracing_motion_blur 1
12123 #define VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION 1
12124 #define VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME "VK_NV_ray_tracing_motion_blur"
12125 
12126 typedef enum VkAccelerationStructureMotionInstanceTypeNV {
12127     VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0,
12128     VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1,
12129     VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2,
12130     VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
12131 } VkAccelerationStructureMotionInstanceTypeNV;
12132 typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV;
12133 typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV;
12134 typedef union VkDeviceOrHostAddressConstKHR {
12135     VkDeviceAddress    deviceAddress;
12136     const void*        hostAddress;
12137 } VkDeviceOrHostAddressConstKHR;
12138 
12139 typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV {
12140     VkStructureType                  sType;
12141     const void*                      pNext;
12142     VkDeviceOrHostAddressConstKHR    vertexData;
12143 } VkAccelerationStructureGeometryMotionTrianglesDataNV;
12144 
12145 typedef struct VkAccelerationStructureMotionInfoNV {
12146     VkStructureType                             sType;
12147     const void*                                 pNext;
12148     uint32_t                                    maxInstances;
12149     VkAccelerationStructureMotionInfoFlagsNV    flags;
12150 } VkAccelerationStructureMotionInfoNV;
12151 
12152 typedef struct VkAccelerationStructureMatrixMotionInstanceNV {
12153     VkTransformMatrixKHR          transformT0;
12154     VkTransformMatrixKHR          transformT1;
12155     uint32_t                      instanceCustomIndex:24;
12156     uint32_t                      mask:8;
12157     uint32_t                      instanceShaderBindingTableRecordOffset:24;
12158     VkGeometryInstanceFlagsKHR    flags:8;
12159     uint64_t                      accelerationStructureReference;
12160 } VkAccelerationStructureMatrixMotionInstanceNV;
12161 
12162 typedef struct VkSRTDataNV {
12163     float    sx;
12164     float    a;
12165     float    b;
12166     float    pvx;
12167     float    sy;
12168     float    c;
12169     float    pvy;
12170     float    sz;
12171     float    pvz;
12172     float    qx;
12173     float    qy;
12174     float    qz;
12175     float    qw;
12176     float    tx;
12177     float    ty;
12178     float    tz;
12179 } VkSRTDataNV;
12180 
12181 typedef struct VkAccelerationStructureSRTMotionInstanceNV {
12182     VkSRTDataNV                   transformT0;
12183     VkSRTDataNV                   transformT1;
12184     uint32_t                      instanceCustomIndex:24;
12185     uint32_t                      mask:8;
12186     uint32_t                      instanceShaderBindingTableRecordOffset:24;
12187     VkGeometryInstanceFlagsKHR    flags:8;
12188     uint64_t                      accelerationStructureReference;
12189 } VkAccelerationStructureSRTMotionInstanceNV;
12190 
12191 typedef union VkAccelerationStructureMotionInstanceDataNV {
12192     VkAccelerationStructureInstanceKHR               staticInstance;
12193     VkAccelerationStructureMatrixMotionInstanceNV    matrixMotionInstance;
12194     VkAccelerationStructureSRTMotionInstanceNV       srtMotionInstance;
12195 } VkAccelerationStructureMotionInstanceDataNV;
12196 
12197 typedef struct VkAccelerationStructureMotionInstanceNV {
12198     VkAccelerationStructureMotionInstanceTypeNV     type;
12199     VkAccelerationStructureMotionInstanceFlagsNV    flags;
12200     VkAccelerationStructureMotionInstanceDataNV     data;
12201 } VkAccelerationStructureMotionInstanceNV;
12202 
12203 typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
12204     VkStructureType    sType;
12205     const void*        pNext;
12206     VkBool32           rayTracingMotionBlur;
12207     VkBool32           rayTracingMotionBlurPipelineTraceRaysIndirect;
12208 } VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;
12209 
12210 
12211 
12212 #define VK_EXT_ycbcr_2plane_444_formats 1
12213 #define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1
12214 #define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats"
12215 typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
12216     VkStructureType    sType;
12217     void*              pNext;
12218     VkBool32           ycbcr2plane444Formats;
12219 } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
12220 
12221 
12222 
12223 #define VK_EXT_fragment_density_map2 1
12224 #define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1
12225 #define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2"
12226 typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
12227     VkStructureType    sType;
12228     void*              pNext;
12229     VkBool32           fragmentDensityMapDeferred;
12230 } VkPhysicalDeviceFragmentDensityMap2FeaturesEXT;
12231 
12232 typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
12233     VkStructureType    sType;
12234     void*              pNext;
12235     VkBool32           subsampledLoads;
12236     VkBool32           subsampledCoarseReconstructionEarlyAccess;
12237     uint32_t           maxSubsampledArrayLayers;
12238     uint32_t           maxDescriptorSetSubsampledSamplers;
12239 } VkPhysicalDeviceFragmentDensityMap2PropertiesEXT;
12240 
12241 
12242 
12243 #define VK_QCOM_rotated_copy_commands 1
12244 #define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1
12245 #define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands"
12246 typedef struct VkCopyCommandTransformInfoQCOM {
12247     VkStructureType                  sType;
12248     const void*                      pNext;
12249     VkSurfaceTransformFlagBitsKHR    transform;
12250 } VkCopyCommandTransformInfoQCOM;
12251 
12252 
12253 
12254 #define VK_EXT_image_robustness 1
12255 #define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1
12256 #define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness"
12257 typedef struct VkPhysicalDeviceImageRobustnessFeaturesEXT {
12258     VkStructureType    sType;
12259     void*              pNext;
12260     VkBool32           robustImageAccess;
12261 } VkPhysicalDeviceImageRobustnessFeaturesEXT;
12262 
12263 
12264 
12265 #define VK_EXT_4444_formats 1
12266 #define VK_EXT_4444_FORMATS_SPEC_VERSION  1
12267 #define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats"
12268 typedef struct VkPhysicalDevice4444FormatsFeaturesEXT {
12269     VkStructureType    sType;
12270     void*              pNext;
12271     VkBool32           formatA4R4G4B4;
12272     VkBool32           formatA4B4G4R4;
12273 } VkPhysicalDevice4444FormatsFeaturesEXT;
12274 
12275 
12276 
12277 #define VK_NV_acquire_winrt_display 1
12278 #define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1
12279 #define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display"
12280 typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
12281 typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);
12282 
12283 #ifndef VK_NO_PROTOTYPES
12284 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(
12285     VkPhysicalDevice                            physicalDevice,
12286     VkDisplayKHR                                display);
12287 
12288 VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(
12289     VkPhysicalDevice                            physicalDevice,
12290     uint32_t                                    deviceRelativeId,
12291     VkDisplayKHR*                               pDisplay);
12292 #endif
12293 
12294 
12295 #define VK_VALVE_mutable_descriptor_type 1
12296 #define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1
12297 #define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type"
12298 typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
12299     VkStructureType    sType;
12300     void*              pNext;
12301     VkBool32           mutableDescriptorType;
12302 } VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
12303 
12304 typedef struct VkMutableDescriptorTypeListVALVE {
12305     uint32_t                   descriptorTypeCount;
12306     const VkDescriptorType*    pDescriptorTypes;
12307 } VkMutableDescriptorTypeListVALVE;
12308 
12309 typedef struct VkMutableDescriptorTypeCreateInfoVALVE {
12310     VkStructureType                            sType;
12311     const void*                                pNext;
12312     uint32_t                                   mutableDescriptorTypeListCount;
12313     const VkMutableDescriptorTypeListVALVE*    pMutableDescriptorTypeLists;
12314 } VkMutableDescriptorTypeCreateInfoVALVE;
12315 
12316 
12317 
12318 #define VK_EXT_vertex_input_dynamic_state 1
12319 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2
12320 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state"
12321 typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
12322     VkStructureType    sType;
12323     void*              pNext;
12324     VkBool32           vertexInputDynamicState;
12325 } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;
12326 
12327 typedef struct VkVertexInputBindingDescription2EXT {
12328     VkStructureType      sType;
12329     void*                pNext;
12330     uint32_t             binding;
12331     uint32_t             stride;
12332     VkVertexInputRate    inputRate;
12333     uint32_t             divisor;
12334 } VkVertexInputBindingDescription2EXT;
12335 
12336 typedef struct VkVertexInputAttributeDescription2EXT {
12337     VkStructureType    sType;
12338     void*              pNext;
12339     uint32_t           location;
12340     uint32_t           binding;
12341     VkFormat           format;
12342     uint32_t           offset;
12343 } VkVertexInputAttributeDescription2EXT;
12344 
12345 typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
12346 
12347 #ifndef VK_NO_PROTOTYPES
12348 VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(
12349     VkCommandBuffer                             commandBuffer,
12350     uint32_t                                    vertexBindingDescriptionCount,
12351     const VkVertexInputBindingDescription2EXT*  pVertexBindingDescriptions,
12352     uint32_t                                    vertexAttributeDescriptionCount,
12353     const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
12354 #endif
12355 
12356 
12357 #define VK_EXT_physical_device_drm 1
12358 #define VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION 1
12359 #define VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME "VK_EXT_physical_device_drm"
12360 typedef struct VkPhysicalDeviceDrmPropertiesEXT {
12361     VkStructureType    sType;
12362     void*              pNext;
12363     VkBool32           hasPrimary;
12364     VkBool32           hasRender;
12365     int64_t            primaryMajor;
12366     int64_t            primaryMinor;
12367     int64_t            renderMajor;
12368     int64_t            renderMinor;
12369 } VkPhysicalDeviceDrmPropertiesEXT;
12370 
12371 
12372 
12373 #define VK_HUAWEI_subpass_shading 1
12374 #define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 0
12375 #define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading"
12376 typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI {
12377     VkStructureType    sType;
12378     void*              pNext;
12379     VkRenderPass       renderPass;
12380     uint32_t           subpass;
12381 } VkSubpassShadingPipelineCreateInfoHUAWEI;
12382 
12383 typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
12384     VkStructureType    sType;
12385     void*              pNext;
12386     VkBool32           subpassShading;
12387 } VkPhysicalDeviceSubpassShadingFeaturesHUAWEI;
12388 
12389 typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
12390     VkStructureType    sType;
12391     void*              pNext;
12392     uint32_t           maxSubpassShadingWorkgroupSizeAspectRatio;
12393 } VkPhysicalDeviceSubpassShadingPropertiesHUAWEI;
12394 
12395 typedef VkResult (VKAPI_PTR *PFN_vkGetSubpassShadingMaxWorkgroupSizeHUAWEI)(VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize);
12396 typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer);
12397 
12398 #ifndef VK_NO_PROTOTYPES
12399 VKAPI_ATTR VkResult VKAPI_CALL vkGetSubpassShadingMaxWorkgroupSizeHUAWEI(
12400     VkRenderPass                                renderpass,
12401     VkExtent2D*                                 pMaxWorkgroupSize);
12402 
12403 VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(
12404     VkCommandBuffer                             commandBuffer);
12405 #endif
12406 
12407 
12408 #define VK_EXT_extended_dynamic_state2 1
12409 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1
12410 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2"
12411 typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
12412     VkStructureType    sType;
12413     void*              pNext;
12414     VkBool32           extendedDynamicState2;
12415     VkBool32           extendedDynamicState2LogicOp;
12416     VkBool32           extendedDynamicState2PatchControlPoints;
12417 } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
12418 
12419 typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints);
12420 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
12421 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);
12422 typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp);
12423 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
12424 
12425 #ifndef VK_NO_PROTOTYPES
12426 VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(
12427     VkCommandBuffer                             commandBuffer,
12428     uint32_t                                    patchControlPoints);
12429 
12430 VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(
12431     VkCommandBuffer                             commandBuffer,
12432     VkBool32                                    rasterizerDiscardEnable);
12433 
12434 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(
12435     VkCommandBuffer                             commandBuffer,
12436     VkBool32                                    depthBiasEnable);
12437 
12438 VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(
12439     VkCommandBuffer                             commandBuffer,
12440     VkLogicOp                                   logicOp);
12441 
12442 VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(
12443     VkCommandBuffer                             commandBuffer,
12444     VkBool32                                    primitiveRestartEnable);
12445 #endif
12446 
12447 
12448 #define VK_EXT_color_write_enable 1
12449 #define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1
12450 #define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable"
12451 typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT {
12452     VkStructureType    sType;
12453     void*              pNext;
12454     VkBool32           colorWriteEnable;
12455 } VkPhysicalDeviceColorWriteEnableFeaturesEXT;
12456 
12457 typedef struct VkPipelineColorWriteCreateInfoEXT {
12458     VkStructureType    sType;
12459     const void*        pNext;
12460     uint32_t           attachmentCount;
12461     const VkBool32*    pColorWriteEnables;
12462 } VkPipelineColorWriteCreateInfoEXT;
12463 
12464 typedef void                                    (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer       commandBuffer, uint32_t                                attachmentCount, const VkBool32*   pColorWriteEnables);
12465 
12466 #ifndef VK_NO_PROTOTYPES
12467 VKAPI_ATTR void                                    VKAPI_CALL vkCmdSetColorWriteEnableEXT(
12468     VkCommandBuffer                             commandBuffer,
12469     uint32_t                                    attachmentCount,
12470     const VkBool32*                             pColorWriteEnables);
12471 #endif
12472 
12473 
12474 #define VK_EXT_global_priority_query 1
12475 #define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT   16U
12476 #define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1
12477 #define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query"
12478 typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT {
12479     VkStructureType    sType;
12480     void*              pNext;
12481     VkBool32           globalPriorityQuery;
12482 } VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT;
12483 
12484 typedef struct VkQueueFamilyGlobalPriorityPropertiesEXT {
12485     VkStructureType             sType;
12486     void*                       pNext;
12487     uint32_t                    priorityCount;
12488     VkQueueGlobalPriorityEXT    priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_EXT];
12489 } VkQueueFamilyGlobalPriorityPropertiesEXT;
12490 
12491 
12492 
12493 #define VK_EXT_multi_draw 1
12494 #define VK_EXT_MULTI_DRAW_SPEC_VERSION    1
12495 #define VK_EXT_MULTI_DRAW_EXTENSION_NAME  "VK_EXT_multi_draw"
12496 typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT {
12497     VkStructureType    sType;
12498     void*              pNext;
12499     VkBool32           multiDraw;
12500 } VkPhysicalDeviceMultiDrawFeaturesEXT;
12501 
12502 typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT {
12503     VkStructureType    sType;
12504     void*              pNext;
12505     uint32_t           maxMultiDrawCount;
12506 } VkPhysicalDeviceMultiDrawPropertiesEXT;
12507 
12508 typedef struct VkMultiDrawInfoEXT {
12509     uint32_t    firstVertex;
12510     uint32_t    vertexCount;
12511 } VkMultiDrawInfoEXT;
12512 
12513 typedef struct VkMultiDrawIndexedInfoEXT {
12514     uint32_t    firstIndex;
12515     uint32_t    indexCount;
12516     int32_t     vertexOffset;
12517 } VkMultiDrawIndexedInfoEXT;
12518 
12519 typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride);
12520 typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset);
12521 
12522 #ifndef VK_NO_PROTOTYPES
12523 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(
12524     VkCommandBuffer                             commandBuffer,
12525     uint32_t                                    drawCount,
12526     const VkMultiDrawInfoEXT*                   pVertexInfo,
12527     uint32_t                                    instanceCount,
12528     uint32_t                                    firstInstance,
12529     uint32_t                                    stride);
12530 
12531 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(
12532     VkCommandBuffer                             commandBuffer,
12533     uint32_t                                    drawCount,
12534     const VkMultiDrawIndexedInfoEXT*            pIndexInfo,
12535     uint32_t                                    instanceCount,
12536     uint32_t                                    firstInstance,
12537     uint32_t                                    stride,
12538     const int32_t*                              pVertexOffset);
12539 #endif
12540 
12541 
12542 #define VK_KHR_acceleration_structure 1
12543 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR)
12544 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 11
12545 #define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure"
12546 
12547 typedef enum VkBuildAccelerationStructureModeKHR {
12548     VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0,
12549     VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1,
12550     VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
12551 } VkBuildAccelerationStructureModeKHR;
12552 
12553 typedef enum VkAccelerationStructureBuildTypeKHR {
12554     VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0,
12555     VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1,
12556     VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2,
12557     VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
12558 } VkAccelerationStructureBuildTypeKHR;
12559 
12560 typedef enum VkAccelerationStructureCompatibilityKHR {
12561     VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0,
12562     VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1,
12563     VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF
12564 } VkAccelerationStructureCompatibilityKHR;
12565 
12566 typedef enum VkAccelerationStructureCreateFlagBitsKHR {
12567     VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001,
12568     VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004,
12569     VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
12570 } VkAccelerationStructureCreateFlagBitsKHR;
12571 typedef VkFlags VkAccelerationStructureCreateFlagsKHR;
12572 typedef union VkDeviceOrHostAddressKHR {
12573     VkDeviceAddress    deviceAddress;
12574     void*              hostAddress;
12575 } VkDeviceOrHostAddressKHR;
12576 
12577 typedef struct VkAccelerationStructureBuildRangeInfoKHR {
12578     uint32_t    primitiveCount;
12579     uint32_t    primitiveOffset;
12580     uint32_t    firstVertex;
12581     uint32_t    transformOffset;
12582 } VkAccelerationStructureBuildRangeInfoKHR;
12583 
12584 typedef struct VkAccelerationStructureGeometryTrianglesDataKHR {
12585     VkStructureType                  sType;
12586     const void*                      pNext;
12587     VkFormat                         vertexFormat;
12588     VkDeviceOrHostAddressConstKHR    vertexData;
12589     VkDeviceSize                     vertexStride;
12590     uint32_t                         maxVertex;
12591     VkIndexType                      indexType;
12592     VkDeviceOrHostAddressConstKHR    indexData;
12593     VkDeviceOrHostAddressConstKHR    transformData;
12594 } VkAccelerationStructureGeometryTrianglesDataKHR;
12595 
12596 typedef struct VkAccelerationStructureGeometryAabbsDataKHR {
12597     VkStructureType                  sType;
12598     const void*                      pNext;
12599     VkDeviceOrHostAddressConstKHR    data;
12600     VkDeviceSize                     stride;
12601 } VkAccelerationStructureGeometryAabbsDataKHR;
12602 
12603 typedef struct VkAccelerationStructureGeometryInstancesDataKHR {
12604     VkStructureType                  sType;
12605     const void*                      pNext;
12606     VkBool32                         arrayOfPointers;
12607     VkDeviceOrHostAddressConstKHR    data;
12608 } VkAccelerationStructureGeometryInstancesDataKHR;
12609 
12610 typedef union VkAccelerationStructureGeometryDataKHR {
12611     VkAccelerationStructureGeometryTrianglesDataKHR    triangles;
12612     VkAccelerationStructureGeometryAabbsDataKHR        aabbs;
12613     VkAccelerationStructureGeometryInstancesDataKHR    instances;
12614 } VkAccelerationStructureGeometryDataKHR;
12615 
12616 typedef struct VkAccelerationStructureGeometryKHR {
12617     VkStructureType                           sType;
12618     const void*                               pNext;
12619     VkGeometryTypeKHR                         geometryType;
12620     VkAccelerationStructureGeometryDataKHR    geometry;
12621     VkGeometryFlagsKHR                        flags;
12622 } VkAccelerationStructureGeometryKHR;
12623 
12624 typedef struct VkAccelerationStructureBuildGeometryInfoKHR {
12625     VkStructureType                                     sType;
12626     const void*                                         pNext;
12627     VkAccelerationStructureTypeKHR                      type;
12628     VkBuildAccelerationStructureFlagsKHR                flags;
12629     VkBuildAccelerationStructureModeKHR                 mode;
12630     VkAccelerationStructureKHR                          srcAccelerationStructure;
12631     VkAccelerationStructureKHR                          dstAccelerationStructure;
12632     uint32_t                                            geometryCount;
12633     const VkAccelerationStructureGeometryKHR*           pGeometries;
12634     const VkAccelerationStructureGeometryKHR* const*    ppGeometries;
12635     VkDeviceOrHostAddressKHR                            scratchData;
12636 } VkAccelerationStructureBuildGeometryInfoKHR;
12637 
12638 typedef struct VkAccelerationStructureCreateInfoKHR {
12639     VkStructureType                          sType;
12640     const void*                              pNext;
12641     VkAccelerationStructureCreateFlagsKHR    createFlags;
12642     VkBuffer                                 buffer;
12643     VkDeviceSize                             offset;
12644     VkDeviceSize                             size;
12645     VkAccelerationStructureTypeKHR           type;
12646     VkDeviceAddress                          deviceAddress;
12647 } VkAccelerationStructureCreateInfoKHR;
12648 
12649 typedef struct VkWriteDescriptorSetAccelerationStructureKHR {
12650     VkStructureType                      sType;
12651     const void*                          pNext;
12652     uint32_t                             accelerationStructureCount;
12653     const VkAccelerationStructureKHR*    pAccelerationStructures;
12654 } VkWriteDescriptorSetAccelerationStructureKHR;
12655 
12656 typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR {
12657     VkStructureType    sType;
12658     void*              pNext;
12659     VkBool32           accelerationStructure;
12660     VkBool32           accelerationStructureCaptureReplay;
12661     VkBool32           accelerationStructureIndirectBuild;
12662     VkBool32           accelerationStructureHostCommands;
12663     VkBool32           descriptorBindingAccelerationStructureUpdateAfterBind;
12664 } VkPhysicalDeviceAccelerationStructureFeaturesKHR;
12665 
12666 typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR {
12667     VkStructureType    sType;
12668     void*              pNext;
12669     uint64_t           maxGeometryCount;
12670     uint64_t           maxInstanceCount;
12671     uint64_t           maxPrimitiveCount;
12672     uint32_t           maxPerStageDescriptorAccelerationStructures;
12673     uint32_t           maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
12674     uint32_t           maxDescriptorSetAccelerationStructures;
12675     uint32_t           maxDescriptorSetUpdateAfterBindAccelerationStructures;
12676     uint32_t           minAccelerationStructureScratchOffsetAlignment;
12677 } VkPhysicalDeviceAccelerationStructurePropertiesKHR;
12678 
12679 typedef struct VkAccelerationStructureDeviceAddressInfoKHR {
12680     VkStructureType               sType;
12681     const void*                   pNext;
12682     VkAccelerationStructureKHR    accelerationStructure;
12683 } VkAccelerationStructureDeviceAddressInfoKHR;
12684 
12685 typedef struct VkAccelerationStructureVersionInfoKHR {
12686     VkStructureType    sType;
12687     const void*        pNext;
12688     const uint8_t*     pVersionData;
12689 } VkAccelerationStructureVersionInfoKHR;
12690 
12691 typedef struct VkCopyAccelerationStructureToMemoryInfoKHR {
12692     VkStructureType                       sType;
12693     const void*                           pNext;
12694     VkAccelerationStructureKHR            src;
12695     VkDeviceOrHostAddressKHR              dst;
12696     VkCopyAccelerationStructureModeKHR    mode;
12697 } VkCopyAccelerationStructureToMemoryInfoKHR;
12698 
12699 typedef struct VkCopyMemoryToAccelerationStructureInfoKHR {
12700     VkStructureType                       sType;
12701     const void*                           pNext;
12702     VkDeviceOrHostAddressConstKHR         src;
12703     VkAccelerationStructureKHR            dst;
12704     VkCopyAccelerationStructureModeKHR    mode;
12705 } VkCopyMemoryToAccelerationStructureInfoKHR;
12706 
12707 typedef struct VkCopyAccelerationStructureInfoKHR {
12708     VkStructureType                       sType;
12709     const void*                           pNext;
12710     VkAccelerationStructureKHR            src;
12711     VkAccelerationStructureKHR            dst;
12712     VkCopyAccelerationStructureModeKHR    mode;
12713 } VkCopyAccelerationStructureInfoKHR;
12714 
12715 typedef struct VkAccelerationStructureBuildSizesInfoKHR {
12716     VkStructureType    sType;
12717     const void*        pNext;
12718     VkDeviceSize       accelerationStructureSize;
12719     VkDeviceSize       updateScratchSize;
12720     VkDeviceSize       buildScratchSize;
12721 } VkAccelerationStructureBuildSizesInfoKHR;
12722 
12723 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice                                           device, const VkAccelerationStructureCreateInfoKHR*        pCreateInfo, const VkAllocationCallbacks*       pAllocator, VkAccelerationStructureKHR*                        pAccelerationStructure);
12724 typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator);
12725 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer                                    commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
12726 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer                  commandBuffer, uint32_t                                           infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress*             pIndirectDeviceAddresses, const uint32_t*                    pIndirectStrides, const uint32_t* const*             ppMaxPrimitiveCounts);
12727 typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice                                           device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
12728 typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo);
12729 typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
12730 typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
12731 typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType  queryType, size_t       dataSize, void* pData, size_t stride);
12732 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo);
12733 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
12734 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
12735 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
12736 typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
12737 typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility);
12738 typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice                                            device, VkAccelerationStructureBuildTypeKHR                 buildType, const VkAccelerationStructureBuildGeometryInfoKHR*  pBuildInfo, const uint32_t*  pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR*           pSizeInfo);
12739 
12740 #ifndef VK_NO_PROTOTYPES
12741 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(
12742     VkDevice                                    device,
12743     const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
12744     const VkAllocationCallbacks*                pAllocator,
12745     VkAccelerationStructureKHR*                 pAccelerationStructure);
12746 
12747 VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(
12748     VkDevice                                    device,
12749     VkAccelerationStructureKHR                  accelerationStructure,
12750     const VkAllocationCallbacks*                pAllocator);
12751 
12752 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(
12753     VkCommandBuffer                             commandBuffer,
12754     uint32_t                                    infoCount,
12755     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
12756     const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
12757 
12758 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(
12759     VkCommandBuffer                             commandBuffer,
12760     uint32_t                                    infoCount,
12761     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
12762     const VkDeviceAddress*                      pIndirectDeviceAddresses,
12763     const uint32_t*                             pIndirectStrides,
12764     const uint32_t* const*                      ppMaxPrimitiveCounts);
12765 
12766 VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(
12767     VkDevice                                    device,
12768     VkDeferredOperationKHR                      deferredOperation,
12769     uint32_t                                    infoCount,
12770     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
12771     const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
12772 
12773 VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(
12774     VkDevice                                    device,
12775     VkDeferredOperationKHR                      deferredOperation,
12776     const VkCopyAccelerationStructureInfoKHR*   pInfo);
12777 
12778 VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(
12779     VkDevice                                    device,
12780     VkDeferredOperationKHR                      deferredOperation,
12781     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
12782 
12783 VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(
12784     VkDevice                                    device,
12785     VkDeferredOperationKHR                      deferredOperation,
12786     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
12787 
12788 VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(
12789     VkDevice                                    device,
12790     uint32_t                                    accelerationStructureCount,
12791     const VkAccelerationStructureKHR*           pAccelerationStructures,
12792     VkQueryType                                 queryType,
12793     size_t                                      dataSize,
12794     void*                                       pData,
12795     size_t                                      stride);
12796 
12797 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(
12798     VkCommandBuffer                             commandBuffer,
12799     const VkCopyAccelerationStructureInfoKHR*   pInfo);
12800 
12801 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(
12802     VkCommandBuffer                             commandBuffer,
12803     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
12804 
12805 VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(
12806     VkCommandBuffer                             commandBuffer,
12807     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
12808 
12809 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(
12810     VkDevice                                    device,
12811     const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
12812 
12813 VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(
12814     VkCommandBuffer                             commandBuffer,
12815     uint32_t                                    accelerationStructureCount,
12816     const VkAccelerationStructureKHR*           pAccelerationStructures,
12817     VkQueryType                                 queryType,
12818     VkQueryPool                                 queryPool,
12819     uint32_t                                    firstQuery);
12820 
12821 VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(
12822     VkDevice                                    device,
12823     const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
12824     VkAccelerationStructureCompatibilityKHR*    pCompatibility);
12825 
12826 VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(
12827     VkDevice                                    device,
12828     VkAccelerationStructureBuildTypeKHR         buildType,
12829     const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
12830     const uint32_t*                             pMaxPrimitiveCounts,
12831     VkAccelerationStructureBuildSizesInfoKHR*   pSizeInfo);
12832 #endif
12833 
12834 
12835 #define VK_KHR_ray_tracing_pipeline 1
12836 #define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1
12837 #define VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME "VK_KHR_ray_tracing_pipeline"
12838 
12839 typedef enum VkShaderGroupShaderKHR {
12840     VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0,
12841     VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1,
12842     VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2,
12843     VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3,
12844     VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF
12845 } VkShaderGroupShaderKHR;
12846 typedef struct VkRayTracingShaderGroupCreateInfoKHR {
12847     VkStructureType                   sType;
12848     const void*                       pNext;
12849     VkRayTracingShaderGroupTypeKHR    type;
12850     uint32_t                          generalShader;
12851     uint32_t                          closestHitShader;
12852     uint32_t                          anyHitShader;
12853     uint32_t                          intersectionShader;
12854     const void*                       pShaderGroupCaptureReplayHandle;
12855 } VkRayTracingShaderGroupCreateInfoKHR;
12856 
12857 typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR {
12858     VkStructureType    sType;
12859     const void*        pNext;
12860     uint32_t           maxPipelineRayPayloadSize;
12861     uint32_t           maxPipelineRayHitAttributeSize;
12862 } VkRayTracingPipelineInterfaceCreateInfoKHR;
12863 
12864 typedef struct VkRayTracingPipelineCreateInfoKHR {
12865     VkStructureType                                      sType;
12866     const void*                                          pNext;
12867     VkPipelineCreateFlags                                flags;
12868     uint32_t                                             stageCount;
12869     const VkPipelineShaderStageCreateInfo*               pStages;
12870     uint32_t                                             groupCount;
12871     const VkRayTracingShaderGroupCreateInfoKHR*          pGroups;
12872     uint32_t                                             maxPipelineRayRecursionDepth;
12873     const VkPipelineLibraryCreateInfoKHR*                pLibraryInfo;
12874     const VkRayTracingPipelineInterfaceCreateInfoKHR*    pLibraryInterface;
12875     const VkPipelineDynamicStateCreateInfo*              pDynamicState;
12876     VkPipelineLayout                                     layout;
12877     VkPipeline                                           basePipelineHandle;
12878     int32_t                                              basePipelineIndex;
12879 } VkRayTracingPipelineCreateInfoKHR;
12880 
12881 typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
12882     VkStructureType    sType;
12883     void*              pNext;
12884     VkBool32           rayTracingPipeline;
12885     VkBool32           rayTracingPipelineShaderGroupHandleCaptureReplay;
12886     VkBool32           rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
12887     VkBool32           rayTracingPipelineTraceRaysIndirect;
12888     VkBool32           rayTraversalPrimitiveCulling;
12889 } VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
12890 
12891 typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
12892     VkStructureType    sType;
12893     void*              pNext;
12894     uint32_t           shaderGroupHandleSize;
12895     uint32_t           maxRayRecursionDepth;
12896     uint32_t           maxShaderGroupStride;
12897     uint32_t           shaderGroupBaseAlignment;
12898     uint32_t           shaderGroupHandleCaptureReplaySize;
12899     uint32_t           maxRayDispatchInvocationCount;
12900     uint32_t           shaderGroupHandleAlignment;
12901     uint32_t           maxRayHitAttributeSize;
12902 } VkPhysicalDeviceRayTracingPipelinePropertiesKHR;
12903 
12904 typedef struct VkStridedDeviceAddressRegionKHR {
12905     VkDeviceAddress    deviceAddress;
12906     VkDeviceSize       stride;
12907     VkDeviceSize       size;
12908 } VkStridedDeviceAddressRegionKHR;
12909 
12910 typedef struct VkTraceRaysIndirectCommandKHR {
12911     uint32_t    width;
12912     uint32_t    height;
12913     uint32_t    depth;
12914 } VkTraceRaysIndirectCommandKHR;
12915 
12916 typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth);
12917 typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
12918 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
12919 typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress);
12920 typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader);
12921 typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize);
12922 
12923 #ifndef VK_NO_PROTOTYPES
12924 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(
12925     VkCommandBuffer                             commandBuffer,
12926     const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
12927     const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
12928     const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
12929     const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
12930     uint32_t                                    width,
12931     uint32_t                                    height,
12932     uint32_t                                    depth);
12933 
12934 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(
12935     VkDevice                                    device,
12936     VkDeferredOperationKHR                      deferredOperation,
12937     VkPipelineCache                             pipelineCache,
12938     uint32_t                                    createInfoCount,
12939     const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
12940     const VkAllocationCallbacks*                pAllocator,
12941     VkPipeline*                                 pPipelines);
12942 
12943 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
12944     VkDevice                                    device,
12945     VkPipeline                                  pipeline,
12946     uint32_t                                    firstGroup,
12947     uint32_t                                    groupCount,
12948     size_t                                      dataSize,
12949     void*                                       pData);
12950 
12951 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(
12952     VkCommandBuffer                             commandBuffer,
12953     const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
12954     const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
12955     const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
12956     const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
12957     VkDeviceAddress                             indirectDeviceAddress);
12958 
12959 VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(
12960     VkDevice                                    device,
12961     VkPipeline                                  pipeline,
12962     uint32_t                                    group,
12963     VkShaderGroupShaderKHR                      groupShader);
12964 
12965 VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(
12966     VkCommandBuffer                             commandBuffer,
12967     uint32_t                                    pipelineStackSize);
12968 #endif
12969 
12970 
12971 #define VK_KHR_ray_query 1
12972 #define VK_KHR_RAY_QUERY_SPEC_VERSION     1
12973 #define VK_KHR_RAY_QUERY_EXTENSION_NAME   "VK_KHR_ray_query"
12974 typedef struct VkPhysicalDeviceRayQueryFeaturesKHR {
12975     VkStructureType    sType;
12976     void*              pNext;
12977     VkBool32           rayQuery;
12978 } VkPhysicalDeviceRayQueryFeaturesKHR;
12979 
12980 
12981 #ifdef __cplusplus
12982 }
12983 #endif
12984 
12985 #endif
12986