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