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