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