1 #ifndef VULKAN_CORE_H_
2 #define VULKAN_CORE_H_ 1
3 
4 /*
5 ** Copyright (c) 2015-2019 The Khronos Group Inc.
6 **
7 ** Licensed under the Apache License, Version 2.0 (the "License");
8 ** you may not use this file except in compliance with the License.
9 ** You may obtain a copy of the License at
10 **
11 **     http://www.apache.org/licenses/LICENSE-2.0
12 **
13 ** Unless required by applicable law or agreed to in writing, software
14 ** distributed under the License is distributed on an "AS IS" BASIS,
15 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 ** See the License for the specific language governing permissions and
17 ** limitations under the License.
18 */
19 
20 /*
21 ** This header is generated from the Khronos Vulkan XML API Registry.
22 **
23 */
24 
25 
26 #ifdef __cplusplus
27 extern "C" {
28 #endif
29 
30 
31 
32 #define VK_VERSION_1_0 1
33 #include "vk_platform.h"
34 #define VK_MAKE_VERSION(major, minor, patch) \
35     (((major) << 22) | ((minor) << 12) | (patch))
36 
37 // 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.
38 //#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
39 
40 // Vulkan 1.0 version number
41 #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
42 
43 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
44 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
45 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
46 // Version of this file
47 #define VK_HEADER_VERSION 130
48 
49 
50 #define VK_NULL_HANDLE 0
51 
52 
53 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
54 
55 
56 #if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
57 #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
58         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
59 #else
60         #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
61 #endif
62 #endif
63 
64 typedef uint32_t VkFlags;
65 typedef uint32_t VkBool32;
66 typedef uint64_t VkDeviceSize;
67 typedef uint32_t VkSampleMask;
68 VK_DEFINE_HANDLE(VkInstance)
69 VK_DEFINE_HANDLE(VkPhysicalDevice)
70 VK_DEFINE_HANDLE(VkDevice)
71 VK_DEFINE_HANDLE(VkQueue)
72 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
73 VK_DEFINE_HANDLE(VkCommandBuffer)
74 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
75 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
76 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
77 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
78 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
79 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
80 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
81 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
82 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
83 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
84 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
85 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
86 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
87 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
88 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
89 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
90 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
91 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
92 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
93 #define VK_LOD_CLAMP_NONE                 1000.0f
94 #define VK_REMAINING_MIP_LEVELS           (~0U)
95 #define VK_REMAINING_ARRAY_LAYERS         (~0U)
96 #define VK_WHOLE_SIZE                     (~0ULL)
97 #define VK_ATTACHMENT_UNUSED              (~0U)
98 #define VK_TRUE                           1
99 #define VK_FALSE                          0
100 #define VK_QUEUE_FAMILY_IGNORED           (~0U)
101 #define VK_SUBPASS_EXTERNAL               (~0U)
102 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
103 #define VK_UUID_SIZE                      16
104 #define VK_MAX_MEMORY_TYPES               32
105 #define VK_MAX_MEMORY_HEAPS               16
106 #define VK_MAX_EXTENSION_NAME_SIZE        256
107 #define VK_MAX_DESCRIPTION_SIZE           256
108 
109 typedef enum VkPipelineCacheHeaderVersion {
110     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
111     VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
112     VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
113     VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
114     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
115 } VkPipelineCacheHeaderVersion;
116 
117 typedef enum VkResult {
118     VK_SUCCESS = 0,
119     VK_NOT_READY = 1,
120     VK_TIMEOUT = 2,
121     VK_EVENT_SET = 3,
122     VK_EVENT_RESET = 4,
123     VK_INCOMPLETE = 5,
124     VK_ERROR_OUT_OF_HOST_MEMORY = -1,
125     VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
126     VK_ERROR_INITIALIZATION_FAILED = -3,
127     VK_ERROR_DEVICE_LOST = -4,
128     VK_ERROR_MEMORY_MAP_FAILED = -5,
129     VK_ERROR_LAYER_NOT_PRESENT = -6,
130     VK_ERROR_EXTENSION_NOT_PRESENT = -7,
131     VK_ERROR_FEATURE_NOT_PRESENT = -8,
132     VK_ERROR_INCOMPATIBLE_DRIVER = -9,
133     VK_ERROR_TOO_MANY_OBJECTS = -10,
134     VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
135     VK_ERROR_FRAGMENTED_POOL = -12,
136     VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,
137     VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
138     VK_ERROR_SURFACE_LOST_KHR = -1000000000,
139     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
140     VK_SUBOPTIMAL_KHR = 1000001003,
141     VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
142     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
143     VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
144     VK_ERROR_INVALID_SHADER_NV = -1000012000,
145     VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
146     VK_ERROR_FRAGMENTATION_EXT = -1000161000,
147     VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
148     VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
149     VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = -1000244000,
150     VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
151     VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
152     VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR,
153     VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
154     VK_RESULT_END_RANGE = VK_INCOMPLETE,
155     VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
156     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
157 } VkResult;
158 
159 typedef enum VkStructureType {
160     VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
161     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
162     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
163     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
164     VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
165     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
166     VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
167     VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
168     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
169     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
170     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
171     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
172     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
173     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
174     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
175     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
176     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
177     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
178     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
179     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
180     VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
181     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
182     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
183     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
184     VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
185     VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
186     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
187     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
188     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
189     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
190     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
191     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
192     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
193     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
194     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
195     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
196     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
197     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
198     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
199     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
200     VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
201     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
202     VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
203     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
204     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
205     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
206     VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
207     VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
208     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
209     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000,
210     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000,
211     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001,
212     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000,
213     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000,
214     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001,
215     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000,
216     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003,
217     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,
218     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005,
219     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006,
220     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,
221     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014,
222     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,
223     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001,
224     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000,
225     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001,
226     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,
227     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003,
228     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004,
229     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000,
230     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001,
231     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002,
232     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003,
233     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004,
234     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005,
235     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006,
236     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007,
237     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008,
238     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000,
239     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001,
240     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002,
241     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
242     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000,
243     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001,
244     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002,
245     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000,
246     VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000,
247     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001,
248     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,
249     VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003,
250     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000,
251     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001,
252     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002,
253     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003,
254     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
255     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005,
256     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000,
257     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,
258     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001,
259     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002,
260     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003,
261     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004,
262     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,
263     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001,
264     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002,
265     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,
266     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001,
267     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000,
268     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000,
269     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,
270     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001,
271     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,
272     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001,
273     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000,
274     VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
275     VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
276     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007,
277     VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008,
278     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009,
279     VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010,
280     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011,
281     VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012,
282     VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
283     VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
284     VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
285     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
286     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
287     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
288     VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
289     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
290     VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
291     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
292     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
293     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
294     VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
295     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
296     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
297     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
298     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000,
299     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001,
300     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002,
301     VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,
302     VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
303     VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000,
304     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000,
305     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
306     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
307     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
308     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
309     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
310     VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
311     VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
312     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000,
313     VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,
314     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,
315     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
316     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
317     VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
318     VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
319     VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
320     VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
321     VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
322     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
323     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
324     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
325     VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
326     VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
327     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
328     VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
329     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
330     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
331     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,
332     VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,
333     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = 1000082000,
334     VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
335     VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
336     VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
337     VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
338     VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
339     VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
340     VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
341     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
342     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
343     VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
344     VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
345     VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
346     VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
347     VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
348     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
349     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
350     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
351     VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
352     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
353     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
354     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
355     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
356     VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
357     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = 1000108000,
358     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = 1000108001,
359     VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = 1000108002,
360     VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = 1000108003,
361     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = 1000109000,
362     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = 1000109001,
363     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = 1000109002,
364     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = 1000109003,
365     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = 1000109004,
366     VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = 1000109005,
367     VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = 1000109006,
368     VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
369     VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
370     VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
371     VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
372     VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
373     VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
374     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,
375     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,
376     VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,
377     VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,
378     VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,
379     VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005,
380     VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,
381     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
382     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
383     VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
384     VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000,
385     VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001,
386     VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002,
387     VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003,
388     VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004,
389     VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
390     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
391     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,
392     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,
393     VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002,
394     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,
395     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004,
396     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000,
397     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001,
398     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
399     VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003,
400     VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,
401     VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005,
402     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
403     VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,
404     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000,
405     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001,
406     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002,
407     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003,
408     VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
409     VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
410     VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
411     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,
412     VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004,
413     VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000,
414     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
415     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
416     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
417     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
418     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
419     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000,
420     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001,
421     VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000,
422     VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158001,
423     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002,
424     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003,
425     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004,
426     VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005,
427     VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,
428     VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,
429     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000,
430     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001,
431     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002,
432     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003,
433     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004,
434     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
435     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,
436     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,
437     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,
438     VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000,
439     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001,
440     VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003,
441     VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004,
442     VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005,
443     VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006,
444     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007,
445     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008,
446     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009,
447     VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011,
448     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012,
449     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,
450     VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,
451     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,
452     VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,
453     VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
454     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = 1000175000,
455     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = 1000177000,
456     VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
457     VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
458     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
459     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000,
460     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
461     VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
462     VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
463     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
464     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
465     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
466     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
467     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
468     VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,
469     VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000,
470     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = 1000196000,
471     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = 1000197000,
472     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = 1000199000,
473     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = 1000199001,
474     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
475     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
476     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,
477     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000,
478     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000,
479     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000,
480     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,
481     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,
482     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,
483     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = 1000207000,
484     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = 1000207001,
485     VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = 1000207002,
486     VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = 1000207003,
487     VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = 1000207004,
488     VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = 1000207005,
489     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000,
490     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = 1000210000,
491     VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001,
492     VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002,
493     VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003,
494     VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004,
495     VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005,
496     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000,
497     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000,
498     VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000,
499     VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001,
500     VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000,
501     VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
502     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000,
503     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,
504     VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,
505     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = 1000221000,
506     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000,
507     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001,
508     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002,
509     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
510     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
511     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
512     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
513     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
514     VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,
515     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,
516     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = 1000241000,
517     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = 1000241001,
518     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = 1000241002,
519     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
520     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
521     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = 1000245000,
522     VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000,
523     VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
524     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000,
525     VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001,
526     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002,
527     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000,
528     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001,
529     VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002,
530     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000,
531     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000,
532     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = 1000253000,
533     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000,
534     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
535     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
536     VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
537     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = 1000257000,
538     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = 1000244001,
539     VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = 1000257002,
540     VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = 1000257003,
541     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = 1000257004,
542     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
543     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
544     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
545     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = 1000261000,
546     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
547     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
548     VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
549     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,
550     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
551     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
552     VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
553     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000,
554     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
555     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001,
556     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
557     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
558     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
559     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
560     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
561     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
562     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
563     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
564     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
565     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
566     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
567     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
568     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
569     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
570     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
571     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
572     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
573     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
574     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
575     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
576     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
577     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
578     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
579     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
580     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
581     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
582     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
583     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
584     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
585     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
586     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
587     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
588     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
589     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
590     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
591     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR,
592     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
593     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
594     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
595     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
596     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
597     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
598     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
599     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
600     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
601     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
602     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
603     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
604     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
605     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
606     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
607     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
608     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
609     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
610     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
611     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
612     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
613     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
614     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
615     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
616     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
617     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
618     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
619     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
620     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
621     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
622     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR,
623     VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
624     VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
625     VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
626     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
627 } VkStructureType;
628 
629 typedef enum VkSystemAllocationScope {
630     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
631     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
632     VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
633     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
634     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
635     VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
636     VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
637     VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
638     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
639 } VkSystemAllocationScope;
640 
641 typedef enum VkInternalAllocationType {
642     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
643     VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
644     VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
645     VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
646     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
647 } VkInternalAllocationType;
648 
649 typedef enum VkFormat {
650     VK_FORMAT_UNDEFINED = 0,
651     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
652     VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
653     VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
654     VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
655     VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
656     VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
657     VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
658     VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
659     VK_FORMAT_R8_UNORM = 9,
660     VK_FORMAT_R8_SNORM = 10,
661     VK_FORMAT_R8_USCALED = 11,
662     VK_FORMAT_R8_SSCALED = 12,
663     VK_FORMAT_R8_UINT = 13,
664     VK_FORMAT_R8_SINT = 14,
665     VK_FORMAT_R8_SRGB = 15,
666     VK_FORMAT_R8G8_UNORM = 16,
667     VK_FORMAT_R8G8_SNORM = 17,
668     VK_FORMAT_R8G8_USCALED = 18,
669     VK_FORMAT_R8G8_SSCALED = 19,
670     VK_FORMAT_R8G8_UINT = 20,
671     VK_FORMAT_R8G8_SINT = 21,
672     VK_FORMAT_R8G8_SRGB = 22,
673     VK_FORMAT_R8G8B8_UNORM = 23,
674     VK_FORMAT_R8G8B8_SNORM = 24,
675     VK_FORMAT_R8G8B8_USCALED = 25,
676     VK_FORMAT_R8G8B8_SSCALED = 26,
677     VK_FORMAT_R8G8B8_UINT = 27,
678     VK_FORMAT_R8G8B8_SINT = 28,
679     VK_FORMAT_R8G8B8_SRGB = 29,
680     VK_FORMAT_B8G8R8_UNORM = 30,
681     VK_FORMAT_B8G8R8_SNORM = 31,
682     VK_FORMAT_B8G8R8_USCALED = 32,
683     VK_FORMAT_B8G8R8_SSCALED = 33,
684     VK_FORMAT_B8G8R8_UINT = 34,
685     VK_FORMAT_B8G8R8_SINT = 35,
686     VK_FORMAT_B8G8R8_SRGB = 36,
687     VK_FORMAT_R8G8B8A8_UNORM = 37,
688     VK_FORMAT_R8G8B8A8_SNORM = 38,
689     VK_FORMAT_R8G8B8A8_USCALED = 39,
690     VK_FORMAT_R8G8B8A8_SSCALED = 40,
691     VK_FORMAT_R8G8B8A8_UINT = 41,
692     VK_FORMAT_R8G8B8A8_SINT = 42,
693     VK_FORMAT_R8G8B8A8_SRGB = 43,
694     VK_FORMAT_B8G8R8A8_UNORM = 44,
695     VK_FORMAT_B8G8R8A8_SNORM = 45,
696     VK_FORMAT_B8G8R8A8_USCALED = 46,
697     VK_FORMAT_B8G8R8A8_SSCALED = 47,
698     VK_FORMAT_B8G8R8A8_UINT = 48,
699     VK_FORMAT_B8G8R8A8_SINT = 49,
700     VK_FORMAT_B8G8R8A8_SRGB = 50,
701     VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
702     VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
703     VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
704     VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
705     VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
706     VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
707     VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
708     VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
709     VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
710     VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
711     VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
712     VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
713     VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
714     VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
715     VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
716     VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
717     VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
718     VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
719     VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
720     VK_FORMAT_R16_UNORM = 70,
721     VK_FORMAT_R16_SNORM = 71,
722     VK_FORMAT_R16_USCALED = 72,
723     VK_FORMAT_R16_SSCALED = 73,
724     VK_FORMAT_R16_UINT = 74,
725     VK_FORMAT_R16_SINT = 75,
726     VK_FORMAT_R16_SFLOAT = 76,
727     VK_FORMAT_R16G16_UNORM = 77,
728     VK_FORMAT_R16G16_SNORM = 78,
729     VK_FORMAT_R16G16_USCALED = 79,
730     VK_FORMAT_R16G16_SSCALED = 80,
731     VK_FORMAT_R16G16_UINT = 81,
732     VK_FORMAT_R16G16_SINT = 82,
733     VK_FORMAT_R16G16_SFLOAT = 83,
734     VK_FORMAT_R16G16B16_UNORM = 84,
735     VK_FORMAT_R16G16B16_SNORM = 85,
736     VK_FORMAT_R16G16B16_USCALED = 86,
737     VK_FORMAT_R16G16B16_SSCALED = 87,
738     VK_FORMAT_R16G16B16_UINT = 88,
739     VK_FORMAT_R16G16B16_SINT = 89,
740     VK_FORMAT_R16G16B16_SFLOAT = 90,
741     VK_FORMAT_R16G16B16A16_UNORM = 91,
742     VK_FORMAT_R16G16B16A16_SNORM = 92,
743     VK_FORMAT_R16G16B16A16_USCALED = 93,
744     VK_FORMAT_R16G16B16A16_SSCALED = 94,
745     VK_FORMAT_R16G16B16A16_UINT = 95,
746     VK_FORMAT_R16G16B16A16_SINT = 96,
747     VK_FORMAT_R16G16B16A16_SFLOAT = 97,
748     VK_FORMAT_R32_UINT = 98,
749     VK_FORMAT_R32_SINT = 99,
750     VK_FORMAT_R32_SFLOAT = 100,
751     VK_FORMAT_R32G32_UINT = 101,
752     VK_FORMAT_R32G32_SINT = 102,
753     VK_FORMAT_R32G32_SFLOAT = 103,
754     VK_FORMAT_R32G32B32_UINT = 104,
755     VK_FORMAT_R32G32B32_SINT = 105,
756     VK_FORMAT_R32G32B32_SFLOAT = 106,
757     VK_FORMAT_R32G32B32A32_UINT = 107,
758     VK_FORMAT_R32G32B32A32_SINT = 108,
759     VK_FORMAT_R32G32B32A32_SFLOAT = 109,
760     VK_FORMAT_R64_UINT = 110,
761     VK_FORMAT_R64_SINT = 111,
762     VK_FORMAT_R64_SFLOAT = 112,
763     VK_FORMAT_R64G64_UINT = 113,
764     VK_FORMAT_R64G64_SINT = 114,
765     VK_FORMAT_R64G64_SFLOAT = 115,
766     VK_FORMAT_R64G64B64_UINT = 116,
767     VK_FORMAT_R64G64B64_SINT = 117,
768     VK_FORMAT_R64G64B64_SFLOAT = 118,
769     VK_FORMAT_R64G64B64A64_UINT = 119,
770     VK_FORMAT_R64G64B64A64_SINT = 120,
771     VK_FORMAT_R64G64B64A64_SFLOAT = 121,
772     VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
773     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
774     VK_FORMAT_D16_UNORM = 124,
775     VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
776     VK_FORMAT_D32_SFLOAT = 126,
777     VK_FORMAT_S8_UINT = 127,
778     VK_FORMAT_D16_UNORM_S8_UINT = 128,
779     VK_FORMAT_D24_UNORM_S8_UINT = 129,
780     VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
781     VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
782     VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
783     VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
784     VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
785     VK_FORMAT_BC2_UNORM_BLOCK = 135,
786     VK_FORMAT_BC2_SRGB_BLOCK = 136,
787     VK_FORMAT_BC3_UNORM_BLOCK = 137,
788     VK_FORMAT_BC3_SRGB_BLOCK = 138,
789     VK_FORMAT_BC4_UNORM_BLOCK = 139,
790     VK_FORMAT_BC4_SNORM_BLOCK = 140,
791     VK_FORMAT_BC5_UNORM_BLOCK = 141,
792     VK_FORMAT_BC5_SNORM_BLOCK = 142,
793     VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
794     VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
795     VK_FORMAT_BC7_UNORM_BLOCK = 145,
796     VK_FORMAT_BC7_SRGB_BLOCK = 146,
797     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
798     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
799     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
800     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
801     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
802     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
803     VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
804     VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
805     VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
806     VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
807     VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
808     VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
809     VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
810     VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
811     VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
812     VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
813     VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
814     VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
815     VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
816     VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
817     VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
818     VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
819     VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
820     VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
821     VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
822     VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
823     VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
824     VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
825     VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
826     VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
827     VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
828     VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
829     VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
830     VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
831     VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
832     VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
833     VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
834     VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
835     VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000,
836     VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001,
837     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,
838     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,
839     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,
840     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,
841     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,
842     VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007,
843     VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,
844     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
845     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
846     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
847     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
848     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
849     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
850     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
851     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
852     VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017,
853     VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,
854     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
855     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
856     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
857     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
858     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
859     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
860     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
861     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
862     VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027,
863     VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028,
864     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,
865     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,
866     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,
867     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,
868     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
869     VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
870     VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
871     VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
872     VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
873     VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
874     VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
875     VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
876     VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
877     VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000,
878     VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001,
879     VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002,
880     VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003,
881     VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004,
882     VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005,
883     VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006,
884     VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007,
885     VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008,
886     VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009,
887     VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010,
888     VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011,
889     VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012,
890     VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013,
891     VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
892     VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
893     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
894     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
895     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
896     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
897     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
898     VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16,
899     VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
900     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
901     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
902     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
903     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
904     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
905     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
906     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
907     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
908     VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16,
909     VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
910     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
911     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
912     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
913     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
914     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
915     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
916     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
917     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
918     VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM,
919     VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM,
920     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
921     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
922     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
923     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
924     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
925     VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
926     VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
927     VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
928     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
929 } VkFormat;
930 
931 typedef enum VkImageType {
932     VK_IMAGE_TYPE_1D = 0,
933     VK_IMAGE_TYPE_2D = 1,
934     VK_IMAGE_TYPE_3D = 2,
935     VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
936     VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
937     VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
938     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
939 } VkImageType;
940 
941 typedef enum VkImageTiling {
942     VK_IMAGE_TILING_OPTIMAL = 0,
943     VK_IMAGE_TILING_LINEAR = 1,
944     VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000,
945     VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
946     VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
947     VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
948     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
949 } VkImageTiling;
950 
951 typedef enum VkPhysicalDeviceType {
952     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
953     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
954     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
955     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
956     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
957     VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
958     VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
959     VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
960     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
961 } VkPhysicalDeviceType;
962 
963 typedef enum VkQueryType {
964     VK_QUERY_TYPE_OCCLUSION = 0,
965     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
966     VK_QUERY_TYPE_TIMESTAMP = 2,
967     VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
968     VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
969     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
970     VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
971     VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
972     VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
973     VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
974     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
975 } VkQueryType;
976 
977 typedef enum VkSharingMode {
978     VK_SHARING_MODE_EXCLUSIVE = 0,
979     VK_SHARING_MODE_CONCURRENT = 1,
980     VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
981     VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
982     VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
983     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
984 } VkSharingMode;
985 
986 typedef enum VkImageLayout {
987     VK_IMAGE_LAYOUT_UNDEFINED = 0,
988     VK_IMAGE_LAYOUT_GENERAL = 1,
989     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
990     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
991     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
992     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
993     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
994     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
995     VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
996     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
997     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
998     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
999     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
1000     VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003,
1001     VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
1002     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = 1000241000,
1003     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = 1000241001,
1004     VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000241002,
1005     VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000241003,
1006     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
1007     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
1008     VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
1009     VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
1010     VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
1011     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
1012 } VkImageLayout;
1013 
1014 typedef enum VkImageViewType {
1015     VK_IMAGE_VIEW_TYPE_1D = 0,
1016     VK_IMAGE_VIEW_TYPE_2D = 1,
1017     VK_IMAGE_VIEW_TYPE_3D = 2,
1018     VK_IMAGE_VIEW_TYPE_CUBE = 3,
1019     VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
1020     VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
1021     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
1022     VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
1023     VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
1024     VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
1025     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
1026 } VkImageViewType;
1027 
1028 typedef enum VkComponentSwizzle {
1029     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
1030     VK_COMPONENT_SWIZZLE_ZERO = 1,
1031     VK_COMPONENT_SWIZZLE_ONE = 2,
1032     VK_COMPONENT_SWIZZLE_R = 3,
1033     VK_COMPONENT_SWIZZLE_G = 4,
1034     VK_COMPONENT_SWIZZLE_B = 5,
1035     VK_COMPONENT_SWIZZLE_A = 6,
1036     VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
1037     VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
1038     VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
1039     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
1040 } VkComponentSwizzle;
1041 
1042 typedef enum VkVertexInputRate {
1043     VK_VERTEX_INPUT_RATE_VERTEX = 0,
1044     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
1045     VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
1046     VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
1047     VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
1048     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
1049 } VkVertexInputRate;
1050 
1051 typedef enum VkPrimitiveTopology {
1052     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
1053     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
1054     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
1055     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
1056     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
1057     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
1058     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
1059     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
1060     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
1061     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
1062     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
1063     VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
1064     VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
1065     VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
1066     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
1067 } VkPrimitiveTopology;
1068 
1069 typedef enum VkPolygonMode {
1070     VK_POLYGON_MODE_FILL = 0,
1071     VK_POLYGON_MODE_LINE = 1,
1072     VK_POLYGON_MODE_POINT = 2,
1073     VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
1074     VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
1075     VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
1076     VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
1077     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
1078 } VkPolygonMode;
1079 
1080 typedef enum VkFrontFace {
1081     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
1082     VK_FRONT_FACE_CLOCKWISE = 1,
1083     VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
1084     VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
1085     VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
1086     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
1087 } VkFrontFace;
1088 
1089 typedef enum VkCompareOp {
1090     VK_COMPARE_OP_NEVER = 0,
1091     VK_COMPARE_OP_LESS = 1,
1092     VK_COMPARE_OP_EQUAL = 2,
1093     VK_COMPARE_OP_LESS_OR_EQUAL = 3,
1094     VK_COMPARE_OP_GREATER = 4,
1095     VK_COMPARE_OP_NOT_EQUAL = 5,
1096     VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
1097     VK_COMPARE_OP_ALWAYS = 7,
1098     VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
1099     VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
1100     VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
1101     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
1102 } VkCompareOp;
1103 
1104 typedef enum VkStencilOp {
1105     VK_STENCIL_OP_KEEP = 0,
1106     VK_STENCIL_OP_ZERO = 1,
1107     VK_STENCIL_OP_REPLACE = 2,
1108     VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
1109     VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
1110     VK_STENCIL_OP_INVERT = 5,
1111     VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
1112     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
1113     VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
1114     VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
1115     VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
1116     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
1117 } VkStencilOp;
1118 
1119 typedef enum VkLogicOp {
1120     VK_LOGIC_OP_CLEAR = 0,
1121     VK_LOGIC_OP_AND = 1,
1122     VK_LOGIC_OP_AND_REVERSE = 2,
1123     VK_LOGIC_OP_COPY = 3,
1124     VK_LOGIC_OP_AND_INVERTED = 4,
1125     VK_LOGIC_OP_NO_OP = 5,
1126     VK_LOGIC_OP_XOR = 6,
1127     VK_LOGIC_OP_OR = 7,
1128     VK_LOGIC_OP_NOR = 8,
1129     VK_LOGIC_OP_EQUIVALENT = 9,
1130     VK_LOGIC_OP_INVERT = 10,
1131     VK_LOGIC_OP_OR_REVERSE = 11,
1132     VK_LOGIC_OP_COPY_INVERTED = 12,
1133     VK_LOGIC_OP_OR_INVERTED = 13,
1134     VK_LOGIC_OP_NAND = 14,
1135     VK_LOGIC_OP_SET = 15,
1136     VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
1137     VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
1138     VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
1139     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
1140 } VkLogicOp;
1141 
1142 typedef enum VkBlendFactor {
1143     VK_BLEND_FACTOR_ZERO = 0,
1144     VK_BLEND_FACTOR_ONE = 1,
1145     VK_BLEND_FACTOR_SRC_COLOR = 2,
1146     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
1147     VK_BLEND_FACTOR_DST_COLOR = 4,
1148     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
1149     VK_BLEND_FACTOR_SRC_ALPHA = 6,
1150     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
1151     VK_BLEND_FACTOR_DST_ALPHA = 8,
1152     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
1153     VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
1154     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
1155     VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
1156     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
1157     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
1158     VK_BLEND_FACTOR_SRC1_COLOR = 15,
1159     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
1160     VK_BLEND_FACTOR_SRC1_ALPHA = 17,
1161     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
1162     VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
1163     VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
1164     VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
1165     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
1166 } VkBlendFactor;
1167 
1168 typedef enum VkBlendOp {
1169     VK_BLEND_OP_ADD = 0,
1170     VK_BLEND_OP_SUBTRACT = 1,
1171     VK_BLEND_OP_REVERSE_SUBTRACT = 2,
1172     VK_BLEND_OP_MIN = 3,
1173     VK_BLEND_OP_MAX = 4,
1174     VK_BLEND_OP_ZERO_EXT = 1000148000,
1175     VK_BLEND_OP_SRC_EXT = 1000148001,
1176     VK_BLEND_OP_DST_EXT = 1000148002,
1177     VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
1178     VK_BLEND_OP_DST_OVER_EXT = 1000148004,
1179     VK_BLEND_OP_SRC_IN_EXT = 1000148005,
1180     VK_BLEND_OP_DST_IN_EXT = 1000148006,
1181     VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
1182     VK_BLEND_OP_DST_OUT_EXT = 1000148008,
1183     VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
1184     VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
1185     VK_BLEND_OP_XOR_EXT = 1000148011,
1186     VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
1187     VK_BLEND_OP_SCREEN_EXT = 1000148013,
1188     VK_BLEND_OP_OVERLAY_EXT = 1000148014,
1189     VK_BLEND_OP_DARKEN_EXT = 1000148015,
1190     VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
1191     VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
1192     VK_BLEND_OP_COLORBURN_EXT = 1000148018,
1193     VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
1194     VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
1195     VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
1196     VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
1197     VK_BLEND_OP_INVERT_EXT = 1000148023,
1198     VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
1199     VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
1200     VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
1201     VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
1202     VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
1203     VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
1204     VK_BLEND_OP_HARDMIX_EXT = 1000148030,
1205     VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
1206     VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
1207     VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
1208     VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
1209     VK_BLEND_OP_PLUS_EXT = 1000148035,
1210     VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
1211     VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
1212     VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
1213     VK_BLEND_OP_MINUS_EXT = 1000148039,
1214     VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
1215     VK_BLEND_OP_CONTRAST_EXT = 1000148041,
1216     VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
1217     VK_BLEND_OP_RED_EXT = 1000148043,
1218     VK_BLEND_OP_GREEN_EXT = 1000148044,
1219     VK_BLEND_OP_BLUE_EXT = 1000148045,
1220     VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
1221     VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
1222     VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
1223     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
1224 } VkBlendOp;
1225 
1226 typedef enum VkDynamicState {
1227     VK_DYNAMIC_STATE_VIEWPORT = 0,
1228     VK_DYNAMIC_STATE_SCISSOR = 1,
1229     VK_DYNAMIC_STATE_LINE_WIDTH = 2,
1230     VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
1231     VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
1232     VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
1233     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
1234     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
1235     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
1236     VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
1237     VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
1238     VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
1239     VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
1240     VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,
1241     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
1242     VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
1243     VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
1244     VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
1245     VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
1246     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
1247 } VkDynamicState;
1248 
1249 typedef enum VkFilter {
1250     VK_FILTER_NEAREST = 0,
1251     VK_FILTER_LINEAR = 1,
1252     VK_FILTER_CUBIC_IMG = 1000015000,
1253     VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG,
1254     VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
1255     VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
1256     VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
1257     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
1258 } VkFilter;
1259 
1260 typedef enum VkSamplerMipmapMode {
1261     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
1262     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
1263     VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
1264     VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
1265     VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
1266     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
1267 } VkSamplerMipmapMode;
1268 
1269 typedef enum VkSamplerAddressMode {
1270     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
1271     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
1272     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
1273     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
1274     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
1275     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
1276     VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
1277     VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
1278     VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
1279     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
1280 } VkSamplerAddressMode;
1281 
1282 typedef enum VkBorderColor {
1283     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
1284     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
1285     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
1286     VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
1287     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
1288     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
1289     VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
1290     VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
1291     VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
1292     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
1293 } VkBorderColor;
1294 
1295 typedef enum VkDescriptorType {
1296     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
1297     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
1298     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
1299     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
1300     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
1301     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
1302     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
1303     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
1304     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
1305     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
1306     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
1307     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000,
1308     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1309     VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
1310     VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
1311     VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
1312     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
1313 } VkDescriptorType;
1314 
1315 typedef enum VkAttachmentLoadOp {
1316     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
1317     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
1318     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
1319     VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
1320     VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1321     VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
1322     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
1323 } VkAttachmentLoadOp;
1324 
1325 typedef enum VkAttachmentStoreOp {
1326     VK_ATTACHMENT_STORE_OP_STORE = 0,
1327     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
1328     VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
1329     VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1330     VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
1331     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
1332 } VkAttachmentStoreOp;
1333 
1334 typedef enum VkPipelineBindPoint {
1335     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
1336     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
1337     VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = 1000165000,
1338     VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
1339     VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
1340     VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
1341     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
1342 } VkPipelineBindPoint;
1343 
1344 typedef enum VkCommandBufferLevel {
1345     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
1346     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
1347     VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1348     VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
1349     VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
1350     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
1351 } VkCommandBufferLevel;
1352 
1353 typedef enum VkIndexType {
1354     VK_INDEX_TYPE_UINT16 = 0,
1355     VK_INDEX_TYPE_UINT32 = 1,
1356     VK_INDEX_TYPE_NONE_NV = 1000165000,
1357     VK_INDEX_TYPE_UINT8_EXT = 1000265000,
1358     VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
1359     VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
1360     VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
1361     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
1362 } VkIndexType;
1363 
1364 typedef enum VkSubpassContents {
1365     VK_SUBPASS_CONTENTS_INLINE = 0,
1366     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
1367     VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
1368     VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
1369     VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
1370     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
1371 } VkSubpassContents;
1372 
1373 typedef enum VkObjectType {
1374     VK_OBJECT_TYPE_UNKNOWN = 0,
1375     VK_OBJECT_TYPE_INSTANCE = 1,
1376     VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
1377     VK_OBJECT_TYPE_DEVICE = 3,
1378     VK_OBJECT_TYPE_QUEUE = 4,
1379     VK_OBJECT_TYPE_SEMAPHORE = 5,
1380     VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
1381     VK_OBJECT_TYPE_FENCE = 7,
1382     VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
1383     VK_OBJECT_TYPE_BUFFER = 9,
1384     VK_OBJECT_TYPE_IMAGE = 10,
1385     VK_OBJECT_TYPE_EVENT = 11,
1386     VK_OBJECT_TYPE_QUERY_POOL = 12,
1387     VK_OBJECT_TYPE_BUFFER_VIEW = 13,
1388     VK_OBJECT_TYPE_IMAGE_VIEW = 14,
1389     VK_OBJECT_TYPE_SHADER_MODULE = 15,
1390     VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
1391     VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
1392     VK_OBJECT_TYPE_RENDER_PASS = 18,
1393     VK_OBJECT_TYPE_PIPELINE = 19,
1394     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
1395     VK_OBJECT_TYPE_SAMPLER = 21,
1396     VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
1397     VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
1398     VK_OBJECT_TYPE_FRAMEBUFFER = 24,
1399     VK_OBJECT_TYPE_COMMAND_POOL = 25,
1400     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,
1401     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
1402     VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
1403     VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
1404     VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
1405     VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
1406     VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
1407     VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000,
1408     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001,
1409     VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,
1410     VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
1411     VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,
1412     VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000,
1413     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
1414     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
1415     VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN,
1416     VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL,
1417     VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1),
1418     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
1419 } VkObjectType;
1420 
1421 typedef enum VkVendorId {
1422     VK_VENDOR_ID_VIV = 0x10001,
1423     VK_VENDOR_ID_VSI = 0x10002,
1424     VK_VENDOR_ID_KAZAN = 0x10003,
1425     VK_VENDOR_ID_BEGIN_RANGE = VK_VENDOR_ID_VIV,
1426     VK_VENDOR_ID_END_RANGE = VK_VENDOR_ID_KAZAN,
1427     VK_VENDOR_ID_RANGE_SIZE = (VK_VENDOR_ID_KAZAN - VK_VENDOR_ID_VIV + 1),
1428     VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
1429 } VkVendorId;
1430 typedef VkFlags VkInstanceCreateFlags;
1431 
1432 typedef enum VkFormatFeatureFlagBits {
1433     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
1434     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
1435     VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
1436     VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
1437     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
1438     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
1439     VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
1440     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
1441     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
1442     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
1443     VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
1444     VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
1445     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
1446     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000,
1447     VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000,
1448     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000,
1449     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000,
1450     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000,
1451     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000,
1452     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000,
1453     VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000,
1454     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000,
1455     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
1456     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000,
1457     VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000,
1458     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
1459     VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
1460     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
1461     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
1462     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
1463     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
1464     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,
1465     VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
1466     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
1467     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
1468     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1469 } VkFormatFeatureFlagBits;
1470 typedef VkFlags VkFormatFeatureFlags;
1471 
1472 typedef enum VkImageUsageFlagBits {
1473     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1474     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
1475     VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
1476     VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
1477     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
1478     VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
1479     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
1480     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
1481     VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00000100,
1482     VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200,
1483     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1484 } VkImageUsageFlagBits;
1485 typedef VkFlags VkImageUsageFlags;
1486 
1487 typedef enum VkImageCreateFlagBits {
1488     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1489     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1490     VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1491     VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
1492     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
1493     VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400,
1494     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040,
1495     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020,
1496     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080,
1497     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,
1498     VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
1499     VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
1500     VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
1501     VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
1502     VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
1503     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
1504     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
1505     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
1506     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
1507     VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
1508     VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
1509     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1510 } VkImageCreateFlagBits;
1511 typedef VkFlags VkImageCreateFlags;
1512 
1513 typedef enum VkSampleCountFlagBits {
1514     VK_SAMPLE_COUNT_1_BIT = 0x00000001,
1515     VK_SAMPLE_COUNT_2_BIT = 0x00000002,
1516     VK_SAMPLE_COUNT_4_BIT = 0x00000004,
1517     VK_SAMPLE_COUNT_8_BIT = 0x00000008,
1518     VK_SAMPLE_COUNT_16_BIT = 0x00000010,
1519     VK_SAMPLE_COUNT_32_BIT = 0x00000020,
1520     VK_SAMPLE_COUNT_64_BIT = 0x00000040,
1521     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1522 } VkSampleCountFlagBits;
1523 typedef VkFlags VkSampleCountFlags;
1524 
1525 typedef enum VkQueueFlagBits {
1526     VK_QUEUE_GRAPHICS_BIT = 0x00000001,
1527     VK_QUEUE_COMPUTE_BIT = 0x00000002,
1528     VK_QUEUE_TRANSFER_BIT = 0x00000004,
1529     VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
1530     VK_QUEUE_PROTECTED_BIT = 0x00000010,
1531     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1532 } VkQueueFlagBits;
1533 typedef VkFlags VkQueueFlags;
1534 
1535 typedef enum VkMemoryPropertyFlagBits {
1536     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
1537     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
1538     VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
1539     VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
1540     VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
1541     VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
1542     VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040,
1543     VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080,
1544     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1545 } VkMemoryPropertyFlagBits;
1546 typedef VkFlags VkMemoryPropertyFlags;
1547 
1548 typedef enum VkMemoryHeapFlagBits {
1549     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
1550     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
1551     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
1552     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1553 } VkMemoryHeapFlagBits;
1554 typedef VkFlags VkMemoryHeapFlags;
1555 typedef VkFlags VkDeviceCreateFlags;
1556 
1557 typedef enum VkDeviceQueueCreateFlagBits {
1558     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,
1559     VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1560 } VkDeviceQueueCreateFlagBits;
1561 typedef VkFlags VkDeviceQueueCreateFlags;
1562 
1563 typedef enum VkPipelineStageFlagBits {
1564     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
1565     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
1566     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
1567     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
1568     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
1569     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
1570     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
1571     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
1572     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
1573     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
1574     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
1575     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
1576     VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
1577     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
1578     VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
1579     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
1580     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
1581     VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,
1582     VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,
1583     VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
1584     VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x00400000,
1585     VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = 0x00200000,
1586     VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000,
1587     VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000,
1588     VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,
1589     VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,
1590     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1591 } VkPipelineStageFlagBits;
1592 typedef VkFlags VkPipelineStageFlags;
1593 typedef VkFlags VkMemoryMapFlags;
1594 
1595 typedef enum VkImageAspectFlagBits {
1596     VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
1597     VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
1598     VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
1599     VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
1600     VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010,
1601     VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020,
1602     VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040,
1603     VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080,
1604     VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,
1605     VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,
1606     VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,
1607     VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
1608     VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
1609     VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
1610     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1611 } VkImageAspectFlagBits;
1612 typedef VkFlags VkImageAspectFlags;
1613 
1614 typedef enum VkSparseImageFormatFlagBits {
1615     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
1616     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
1617     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
1618     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1619 } VkSparseImageFormatFlagBits;
1620 typedef VkFlags VkSparseImageFormatFlags;
1621 
1622 typedef enum VkSparseMemoryBindFlagBits {
1623     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
1624     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1625 } VkSparseMemoryBindFlagBits;
1626 typedef VkFlags VkSparseMemoryBindFlags;
1627 
1628 typedef enum VkFenceCreateFlagBits {
1629     VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
1630     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1631 } VkFenceCreateFlagBits;
1632 typedef VkFlags VkFenceCreateFlags;
1633 typedef VkFlags VkSemaphoreCreateFlags;
1634 typedef VkFlags VkEventCreateFlags;
1635 typedef VkFlags VkQueryPoolCreateFlags;
1636 
1637 typedef enum VkQueryPipelineStatisticFlagBits {
1638     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
1639     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
1640     VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
1641     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
1642     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
1643     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
1644     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
1645     VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
1646     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
1647     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
1648     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
1649     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1650 } VkQueryPipelineStatisticFlagBits;
1651 typedef VkFlags VkQueryPipelineStatisticFlags;
1652 
1653 typedef enum VkQueryResultFlagBits {
1654     VK_QUERY_RESULT_64_BIT = 0x00000001,
1655     VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
1656     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
1657     VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
1658     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1659 } VkQueryResultFlagBits;
1660 typedef VkFlags VkQueryResultFlags;
1661 
1662 typedef enum VkBufferCreateFlagBits {
1663     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1664     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1665     VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1666     VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
1667     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000010,
1668     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR,
1669     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1670 } VkBufferCreateFlagBits;
1671 typedef VkFlags VkBufferCreateFlags;
1672 
1673 typedef enum VkBufferUsageFlagBits {
1674     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1675     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
1676     VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
1677     VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
1678     VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
1679     VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
1680     VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
1681     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
1682     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
1683     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800,
1684     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
1685     VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
1686     VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400,
1687     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000,
1688     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR,
1689     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1690 } VkBufferUsageFlagBits;
1691 typedef VkFlags VkBufferUsageFlags;
1692 typedef VkFlags VkBufferViewCreateFlags;
1693 
1694 typedef enum VkImageViewCreateFlagBits {
1695     VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001,
1696     VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1697 } VkImageViewCreateFlagBits;
1698 typedef VkFlags VkImageViewCreateFlags;
1699 
1700 typedef enum VkShaderModuleCreateFlagBits {
1701     VK_SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1702 } VkShaderModuleCreateFlagBits;
1703 typedef VkFlags VkShaderModuleCreateFlags;
1704 typedef VkFlags VkPipelineCacheCreateFlags;
1705 
1706 typedef enum VkPipelineCreateFlagBits {
1707     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
1708     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
1709     VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
1710     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
1711     VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,
1712     VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
1713     VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
1714     VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
1715     VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
1716     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
1717     VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
1718     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1719 } VkPipelineCreateFlagBits;
1720 typedef VkFlags VkPipelineCreateFlags;
1721 
1722 typedef enum VkPipelineShaderStageCreateFlagBits {
1723     VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001,
1724     VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002,
1725     VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1726 } VkPipelineShaderStageCreateFlagBits;
1727 typedef VkFlags VkPipelineShaderStageCreateFlags;
1728 
1729 typedef enum VkShaderStageFlagBits {
1730     VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
1731     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
1732     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
1733     VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
1734     VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
1735     VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
1736     VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
1737     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
1738     VK_SHADER_STAGE_RAYGEN_BIT_NV = 0x00000100,
1739     VK_SHADER_STAGE_ANY_HIT_BIT_NV = 0x00000200,
1740     VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = 0x00000400,
1741     VK_SHADER_STAGE_MISS_BIT_NV = 0x00000800,
1742     VK_SHADER_STAGE_INTERSECTION_BIT_NV = 0x00001000,
1743     VK_SHADER_STAGE_CALLABLE_BIT_NV = 0x00002000,
1744     VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040,
1745     VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,
1746     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1747 } VkShaderStageFlagBits;
1748 typedef VkFlags VkPipelineVertexInputStateCreateFlags;
1749 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
1750 typedef VkFlags VkPipelineTessellationStateCreateFlags;
1751 typedef VkFlags VkPipelineViewportStateCreateFlags;
1752 typedef VkFlags VkPipelineRasterizationStateCreateFlags;
1753 
1754 typedef enum VkCullModeFlagBits {
1755     VK_CULL_MODE_NONE = 0,
1756     VK_CULL_MODE_FRONT_BIT = 0x00000001,
1757     VK_CULL_MODE_BACK_BIT = 0x00000002,
1758     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
1759     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1760 } VkCullModeFlagBits;
1761 typedef VkFlags VkCullModeFlags;
1762 typedef VkFlags VkPipelineMultisampleStateCreateFlags;
1763 typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
1764 typedef VkFlags VkPipelineColorBlendStateCreateFlags;
1765 
1766 typedef enum VkColorComponentFlagBits {
1767     VK_COLOR_COMPONENT_R_BIT = 0x00000001,
1768     VK_COLOR_COMPONENT_G_BIT = 0x00000002,
1769     VK_COLOR_COMPONENT_B_BIT = 0x00000004,
1770     VK_COLOR_COMPONENT_A_BIT = 0x00000008,
1771     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1772 } VkColorComponentFlagBits;
1773 typedef VkFlags VkColorComponentFlags;
1774 typedef VkFlags VkPipelineDynamicStateCreateFlags;
1775 typedef VkFlags VkPipelineLayoutCreateFlags;
1776 typedef VkFlags VkShaderStageFlags;
1777 
1778 typedef enum VkSamplerCreateFlagBits {
1779     VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001,
1780     VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002,
1781     VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1782 } VkSamplerCreateFlagBits;
1783 typedef VkFlags VkSamplerCreateFlags;
1784 
1785 typedef enum VkDescriptorSetLayoutCreateFlagBits {
1786     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
1787     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 0x00000002,
1788     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1789 } VkDescriptorSetLayoutCreateFlagBits;
1790 typedef VkFlags VkDescriptorSetLayoutCreateFlags;
1791 
1792 typedef enum VkDescriptorPoolCreateFlagBits {
1793     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
1794     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 0x00000002,
1795     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1796 } VkDescriptorPoolCreateFlagBits;
1797 typedef VkFlags VkDescriptorPoolCreateFlags;
1798 typedef VkFlags VkDescriptorPoolResetFlags;
1799 
1800 typedef enum VkFramebufferCreateFlagBits {
1801     VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = 0x00000001,
1802     VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1803 } VkFramebufferCreateFlagBits;
1804 typedef VkFlags VkFramebufferCreateFlags;
1805 
1806 typedef enum VkRenderPassCreateFlagBits {
1807     VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1808 } VkRenderPassCreateFlagBits;
1809 typedef VkFlags VkRenderPassCreateFlags;
1810 
1811 typedef enum VkAttachmentDescriptionFlagBits {
1812     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
1813     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1814 } VkAttachmentDescriptionFlagBits;
1815 typedef VkFlags VkAttachmentDescriptionFlags;
1816 
1817 typedef enum VkSubpassDescriptionFlagBits {
1818     VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
1819     VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
1820     VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1821 } VkSubpassDescriptionFlagBits;
1822 typedef VkFlags VkSubpassDescriptionFlags;
1823 
1824 typedef enum VkAccessFlagBits {
1825     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
1826     VK_ACCESS_INDEX_READ_BIT = 0x00000002,
1827     VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
1828     VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
1829     VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
1830     VK_ACCESS_SHADER_READ_BIT = 0x00000020,
1831     VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
1832     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
1833     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
1834     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
1835     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
1836     VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
1837     VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
1838     VK_ACCESS_HOST_READ_BIT = 0x00002000,
1839     VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
1840     VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
1841     VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
1842     VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,
1843     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,
1844     VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,
1845     VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,
1846     VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
1847     VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
1848     VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
1849     VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000,
1850     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000,
1851     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000,
1852     VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000,
1853     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1854 } VkAccessFlagBits;
1855 typedef VkFlags VkAccessFlags;
1856 
1857 typedef enum VkDependencyFlagBits {
1858     VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
1859     VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,
1860     VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,
1861     VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
1862     VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
1863     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1864 } VkDependencyFlagBits;
1865 typedef VkFlags VkDependencyFlags;
1866 
1867 typedef enum VkCommandPoolCreateFlagBits {
1868     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
1869     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
1870     VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004,
1871     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1872 } VkCommandPoolCreateFlagBits;
1873 typedef VkFlags VkCommandPoolCreateFlags;
1874 
1875 typedef enum VkCommandPoolResetFlagBits {
1876     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1877     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1878 } VkCommandPoolResetFlagBits;
1879 typedef VkFlags VkCommandPoolResetFlags;
1880 
1881 typedef enum VkCommandBufferUsageFlagBits {
1882     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
1883     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
1884     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
1885     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1886 } VkCommandBufferUsageFlagBits;
1887 typedef VkFlags VkCommandBufferUsageFlags;
1888 
1889 typedef enum VkQueryControlFlagBits {
1890     VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
1891     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1892 } VkQueryControlFlagBits;
1893 typedef VkFlags VkQueryControlFlags;
1894 
1895 typedef enum VkCommandBufferResetFlagBits {
1896     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1897     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1898 } VkCommandBufferResetFlagBits;
1899 typedef VkFlags VkCommandBufferResetFlags;
1900 
1901 typedef enum VkStencilFaceFlagBits {
1902     VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
1903     VK_STENCIL_FACE_BACK_BIT = 0x00000002,
1904     VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,
1905     VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
1906     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1907 } VkStencilFaceFlagBits;
1908 typedef VkFlags VkStencilFaceFlags;
1909 typedef struct VkApplicationInfo {
1910     VkStructureType    sType;
1911     const void*        pNext;
1912     const char*        pApplicationName;
1913     uint32_t           applicationVersion;
1914     const char*        pEngineName;
1915     uint32_t           engineVersion;
1916     uint32_t           apiVersion;
1917 } VkApplicationInfo;
1918 
1919 typedef struct VkInstanceCreateInfo {
1920     VkStructureType             sType;
1921     const void*                 pNext;
1922     VkInstanceCreateFlags       flags;
1923     const VkApplicationInfo*    pApplicationInfo;
1924     uint32_t                    enabledLayerCount;
1925     const char* const*          ppEnabledLayerNames;
1926     uint32_t                    enabledExtensionCount;
1927     const char* const*          ppEnabledExtensionNames;
1928 } VkInstanceCreateInfo;
1929 
1930 typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
1931     void*                                       pUserData,
1932     size_t                                      size,
1933     size_t                                      alignment,
1934     VkSystemAllocationScope                     allocationScope);
1935 
1936 typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
1937     void*                                       pUserData,
1938     void*                                       pOriginal,
1939     size_t                                      size,
1940     size_t                                      alignment,
1941     VkSystemAllocationScope                     allocationScope);
1942 
1943 typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
1944     void*                                       pUserData,
1945     void*                                       pMemory);
1946 
1947 typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
1948     void*                                       pUserData,
1949     size_t                                      size,
1950     VkInternalAllocationType                    allocationType,
1951     VkSystemAllocationScope                     allocationScope);
1952 
1953 typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
1954     void*                                       pUserData,
1955     size_t                                      size,
1956     VkInternalAllocationType                    allocationType,
1957     VkSystemAllocationScope                     allocationScope);
1958 
1959 typedef struct VkAllocationCallbacks {
1960     void*                                   pUserData;
1961     PFN_vkAllocationFunction                pfnAllocation;
1962     PFN_vkReallocationFunction              pfnReallocation;
1963     PFN_vkFreeFunction                      pfnFree;
1964     PFN_vkInternalAllocationNotification    pfnInternalAllocation;
1965     PFN_vkInternalFreeNotification          pfnInternalFree;
1966 } VkAllocationCallbacks;
1967 
1968 typedef struct VkPhysicalDeviceFeatures {
1969     VkBool32    robustBufferAccess;
1970     VkBool32    fullDrawIndexUint32;
1971     VkBool32    imageCubeArray;
1972     VkBool32    independentBlend;
1973     VkBool32    geometryShader;
1974     VkBool32    tessellationShader;
1975     VkBool32    sampleRateShading;
1976     VkBool32    dualSrcBlend;
1977     VkBool32    logicOp;
1978     VkBool32    multiDrawIndirect;
1979     VkBool32    drawIndirectFirstInstance;
1980     VkBool32    depthClamp;
1981     VkBool32    depthBiasClamp;
1982     VkBool32    fillModeNonSolid;
1983     VkBool32    depthBounds;
1984     VkBool32    wideLines;
1985     VkBool32    largePoints;
1986     VkBool32    alphaToOne;
1987     VkBool32    multiViewport;
1988     VkBool32    samplerAnisotropy;
1989     VkBool32    textureCompressionETC2;
1990     VkBool32    textureCompressionASTC_LDR;
1991     VkBool32    textureCompressionBC;
1992     VkBool32    occlusionQueryPrecise;
1993     VkBool32    pipelineStatisticsQuery;
1994     VkBool32    vertexPipelineStoresAndAtomics;
1995     VkBool32    fragmentStoresAndAtomics;
1996     VkBool32    shaderTessellationAndGeometryPointSize;
1997     VkBool32    shaderImageGatherExtended;
1998     VkBool32    shaderStorageImageExtendedFormats;
1999     VkBool32    shaderStorageImageMultisample;
2000     VkBool32    shaderStorageImageReadWithoutFormat;
2001     VkBool32    shaderStorageImageWriteWithoutFormat;
2002     VkBool32    shaderUniformBufferArrayDynamicIndexing;
2003     VkBool32    shaderSampledImageArrayDynamicIndexing;
2004     VkBool32    shaderStorageBufferArrayDynamicIndexing;
2005     VkBool32    shaderStorageImageArrayDynamicIndexing;
2006     VkBool32    shaderClipDistance;
2007     VkBool32    shaderCullDistance;
2008     VkBool32    shaderFloat64;
2009     VkBool32    shaderInt64;
2010     VkBool32    shaderInt16;
2011     VkBool32    shaderResourceResidency;
2012     VkBool32    shaderResourceMinLod;
2013     VkBool32    sparseBinding;
2014     VkBool32    sparseResidencyBuffer;
2015     VkBool32    sparseResidencyImage2D;
2016     VkBool32    sparseResidencyImage3D;
2017     VkBool32    sparseResidency2Samples;
2018     VkBool32    sparseResidency4Samples;
2019     VkBool32    sparseResidency8Samples;
2020     VkBool32    sparseResidency16Samples;
2021     VkBool32    sparseResidencyAliased;
2022     VkBool32    variableMultisampleRate;
2023     VkBool32    inheritedQueries;
2024 } VkPhysicalDeviceFeatures;
2025 
2026 typedef struct VkFormatProperties {
2027     VkFormatFeatureFlags    linearTilingFeatures;
2028     VkFormatFeatureFlags    optimalTilingFeatures;
2029     VkFormatFeatureFlags    bufferFeatures;
2030 } VkFormatProperties;
2031 
2032 typedef struct VkExtent3D {
2033     uint32_t    width;
2034     uint32_t    height;
2035     uint32_t    depth;
2036 } VkExtent3D;
2037 
2038 typedef struct VkImageFormatProperties {
2039     VkExtent3D            maxExtent;
2040     uint32_t              maxMipLevels;
2041     uint32_t              maxArrayLayers;
2042     VkSampleCountFlags    sampleCounts;
2043     VkDeviceSize          maxResourceSize;
2044 } VkImageFormatProperties;
2045 
2046 typedef struct VkPhysicalDeviceLimits {
2047     uint32_t              maxImageDimension1D;
2048     uint32_t              maxImageDimension2D;
2049     uint32_t              maxImageDimension3D;
2050     uint32_t              maxImageDimensionCube;
2051     uint32_t              maxImageArrayLayers;
2052     uint32_t              maxTexelBufferElements;
2053     uint32_t              maxUniformBufferRange;
2054     uint32_t              maxStorageBufferRange;
2055     uint32_t              maxPushConstantsSize;
2056     uint32_t              maxMemoryAllocationCount;
2057     uint32_t              maxSamplerAllocationCount;
2058     VkDeviceSize          bufferImageGranularity;
2059     VkDeviceSize          sparseAddressSpaceSize;
2060     uint32_t              maxBoundDescriptorSets;
2061     uint32_t              maxPerStageDescriptorSamplers;
2062     uint32_t              maxPerStageDescriptorUniformBuffers;
2063     uint32_t              maxPerStageDescriptorStorageBuffers;
2064     uint32_t              maxPerStageDescriptorSampledImages;
2065     uint32_t              maxPerStageDescriptorStorageImages;
2066     uint32_t              maxPerStageDescriptorInputAttachments;
2067     uint32_t              maxPerStageResources;
2068     uint32_t              maxDescriptorSetSamplers;
2069     uint32_t              maxDescriptorSetUniformBuffers;
2070     uint32_t              maxDescriptorSetUniformBuffersDynamic;
2071     uint32_t              maxDescriptorSetStorageBuffers;
2072     uint32_t              maxDescriptorSetStorageBuffersDynamic;
2073     uint32_t              maxDescriptorSetSampledImages;
2074     uint32_t              maxDescriptorSetStorageImages;
2075     uint32_t              maxDescriptorSetInputAttachments;
2076     uint32_t              maxVertexInputAttributes;
2077     uint32_t              maxVertexInputBindings;
2078     uint32_t              maxVertexInputAttributeOffset;
2079     uint32_t              maxVertexInputBindingStride;
2080     uint32_t              maxVertexOutputComponents;
2081     uint32_t              maxTessellationGenerationLevel;
2082     uint32_t              maxTessellationPatchSize;
2083     uint32_t              maxTessellationControlPerVertexInputComponents;
2084     uint32_t              maxTessellationControlPerVertexOutputComponents;
2085     uint32_t              maxTessellationControlPerPatchOutputComponents;
2086     uint32_t              maxTessellationControlTotalOutputComponents;
2087     uint32_t              maxTessellationEvaluationInputComponents;
2088     uint32_t              maxTessellationEvaluationOutputComponents;
2089     uint32_t              maxGeometryShaderInvocations;
2090     uint32_t              maxGeometryInputComponents;
2091     uint32_t              maxGeometryOutputComponents;
2092     uint32_t              maxGeometryOutputVertices;
2093     uint32_t              maxGeometryTotalOutputComponents;
2094     uint32_t              maxFragmentInputComponents;
2095     uint32_t              maxFragmentOutputAttachments;
2096     uint32_t              maxFragmentDualSrcAttachments;
2097     uint32_t              maxFragmentCombinedOutputResources;
2098     uint32_t              maxComputeSharedMemorySize;
2099     uint32_t              maxComputeWorkGroupCount[3];
2100     uint32_t              maxComputeWorkGroupInvocations;
2101     uint32_t              maxComputeWorkGroupSize[3];
2102     uint32_t              subPixelPrecisionBits;
2103     uint32_t              subTexelPrecisionBits;
2104     uint32_t              mipmapPrecisionBits;
2105     uint32_t              maxDrawIndexedIndexValue;
2106     uint32_t              maxDrawIndirectCount;
2107     float                 maxSamplerLodBias;
2108     float                 maxSamplerAnisotropy;
2109     uint32_t              maxViewports;
2110     uint32_t              maxViewportDimensions[2];
2111     float                 viewportBoundsRange[2];
2112     uint32_t              viewportSubPixelBits;
2113     size_t                minMemoryMapAlignment;
2114     VkDeviceSize          minTexelBufferOffsetAlignment;
2115     VkDeviceSize          minUniformBufferOffsetAlignment;
2116     VkDeviceSize          minStorageBufferOffsetAlignment;
2117     int32_t               minTexelOffset;
2118     uint32_t              maxTexelOffset;
2119     int32_t               minTexelGatherOffset;
2120     uint32_t              maxTexelGatherOffset;
2121     float                 minInterpolationOffset;
2122     float                 maxInterpolationOffset;
2123     uint32_t              subPixelInterpolationOffsetBits;
2124     uint32_t              maxFramebufferWidth;
2125     uint32_t              maxFramebufferHeight;
2126     uint32_t              maxFramebufferLayers;
2127     VkSampleCountFlags    framebufferColorSampleCounts;
2128     VkSampleCountFlags    framebufferDepthSampleCounts;
2129     VkSampleCountFlags    framebufferStencilSampleCounts;
2130     VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
2131     uint32_t              maxColorAttachments;
2132     VkSampleCountFlags    sampledImageColorSampleCounts;
2133     VkSampleCountFlags    sampledImageIntegerSampleCounts;
2134     VkSampleCountFlags    sampledImageDepthSampleCounts;
2135     VkSampleCountFlags    sampledImageStencilSampleCounts;
2136     VkSampleCountFlags    storageImageSampleCounts;
2137     uint32_t              maxSampleMaskWords;
2138     VkBool32              timestampComputeAndGraphics;
2139     float                 timestampPeriod;
2140     uint32_t              maxClipDistances;
2141     uint32_t              maxCullDistances;
2142     uint32_t              maxCombinedClipAndCullDistances;
2143     uint32_t              discreteQueuePriorities;
2144     float                 pointSizeRange[2];
2145     float                 lineWidthRange[2];
2146     float                 pointSizeGranularity;
2147     float                 lineWidthGranularity;
2148     VkBool32              strictLines;
2149     VkBool32              standardSampleLocations;
2150     VkDeviceSize          optimalBufferCopyOffsetAlignment;
2151     VkDeviceSize          optimalBufferCopyRowPitchAlignment;
2152     VkDeviceSize          nonCoherentAtomSize;
2153 } VkPhysicalDeviceLimits;
2154 
2155 typedef struct VkPhysicalDeviceSparseProperties {
2156     VkBool32    residencyStandard2DBlockShape;
2157     VkBool32    residencyStandard2DMultisampleBlockShape;
2158     VkBool32    residencyStandard3DBlockShape;
2159     VkBool32    residencyAlignedMipSize;
2160     VkBool32    residencyNonResidentStrict;
2161 } VkPhysicalDeviceSparseProperties;
2162 
2163 typedef struct VkPhysicalDeviceProperties {
2164     uint32_t                            apiVersion;
2165     uint32_t                            driverVersion;
2166     uint32_t                            vendorID;
2167     uint32_t                            deviceID;
2168     VkPhysicalDeviceType                deviceType;
2169     char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
2170     uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
2171     VkPhysicalDeviceLimits              limits;
2172     VkPhysicalDeviceSparseProperties    sparseProperties;
2173 } VkPhysicalDeviceProperties;
2174 
2175 typedef struct VkQueueFamilyProperties {
2176     VkQueueFlags    queueFlags;
2177     uint32_t        queueCount;
2178     uint32_t        timestampValidBits;
2179     VkExtent3D      minImageTransferGranularity;
2180 } VkQueueFamilyProperties;
2181 
2182 typedef struct VkMemoryType {
2183     VkMemoryPropertyFlags    propertyFlags;
2184     uint32_t                 heapIndex;
2185 } VkMemoryType;
2186 
2187 typedef struct VkMemoryHeap {
2188     VkDeviceSize         size;
2189     VkMemoryHeapFlags    flags;
2190 } VkMemoryHeap;
2191 
2192 typedef struct VkPhysicalDeviceMemoryProperties {
2193     uint32_t        memoryTypeCount;
2194     VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
2195     uint32_t        memoryHeapCount;
2196     VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
2197 } VkPhysicalDeviceMemoryProperties;
2198 
2199 typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
2200 typedef struct VkDeviceQueueCreateInfo {
2201     VkStructureType             sType;
2202     const void*                 pNext;
2203     VkDeviceQueueCreateFlags    flags;
2204     uint32_t                    queueFamilyIndex;
2205     uint32_t                    queueCount;
2206     const float*                pQueuePriorities;
2207 } VkDeviceQueueCreateInfo;
2208 
2209 typedef struct VkDeviceCreateInfo {
2210     VkStructureType                    sType;
2211     const void*                        pNext;
2212     VkDeviceCreateFlags                flags;
2213     uint32_t                           queueCreateInfoCount;
2214     const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
2215     uint32_t                           enabledLayerCount;
2216     const char* const*                 ppEnabledLayerNames;
2217     uint32_t                           enabledExtensionCount;
2218     const char* const*                 ppEnabledExtensionNames;
2219     const VkPhysicalDeviceFeatures*    pEnabledFeatures;
2220 } VkDeviceCreateInfo;
2221 
2222 typedef struct VkExtensionProperties {
2223     char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
2224     uint32_t    specVersion;
2225 } VkExtensionProperties;
2226 
2227 typedef struct VkLayerProperties {
2228     char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
2229     uint32_t    specVersion;
2230     uint32_t    implementationVersion;
2231     char        description[VK_MAX_DESCRIPTION_SIZE];
2232 } VkLayerProperties;
2233 
2234 typedef struct VkSubmitInfo {
2235     VkStructureType                sType;
2236     const void*                    pNext;
2237     uint32_t                       waitSemaphoreCount;
2238     const VkSemaphore*             pWaitSemaphores;
2239     const VkPipelineStageFlags*    pWaitDstStageMask;
2240     uint32_t                       commandBufferCount;
2241     const VkCommandBuffer*         pCommandBuffers;
2242     uint32_t                       signalSemaphoreCount;
2243     const VkSemaphore*             pSignalSemaphores;
2244 } VkSubmitInfo;
2245 
2246 typedef struct VkMemoryAllocateInfo {
2247     VkStructureType    sType;
2248     const void*        pNext;
2249     VkDeviceSize       allocationSize;
2250     uint32_t           memoryTypeIndex;
2251 } VkMemoryAllocateInfo;
2252 
2253 typedef struct VkMappedMemoryRange {
2254     VkStructureType    sType;
2255     const void*        pNext;
2256     VkDeviceMemory     memory;
2257     VkDeviceSize       offset;
2258     VkDeviceSize       size;
2259 } VkMappedMemoryRange;
2260 
2261 typedef struct VkMemoryRequirements {
2262     VkDeviceSize    size;
2263     VkDeviceSize    alignment;
2264     uint32_t        memoryTypeBits;
2265 } VkMemoryRequirements;
2266 
2267 typedef struct VkSparseImageFormatProperties {
2268     VkImageAspectFlags          aspectMask;
2269     VkExtent3D                  imageGranularity;
2270     VkSparseImageFormatFlags    flags;
2271 } VkSparseImageFormatProperties;
2272 
2273 typedef struct VkSparseImageMemoryRequirements {
2274     VkSparseImageFormatProperties    formatProperties;
2275     uint32_t                         imageMipTailFirstLod;
2276     VkDeviceSize                     imageMipTailSize;
2277     VkDeviceSize                     imageMipTailOffset;
2278     VkDeviceSize                     imageMipTailStride;
2279 } VkSparseImageMemoryRequirements;
2280 
2281 typedef struct VkSparseMemoryBind {
2282     VkDeviceSize               resourceOffset;
2283     VkDeviceSize               size;
2284     VkDeviceMemory             memory;
2285     VkDeviceSize               memoryOffset;
2286     VkSparseMemoryBindFlags    flags;
2287 } VkSparseMemoryBind;
2288 
2289 typedef struct VkSparseBufferMemoryBindInfo {
2290     VkBuffer                     buffer;
2291     uint32_t                     bindCount;
2292     const VkSparseMemoryBind*    pBinds;
2293 } VkSparseBufferMemoryBindInfo;
2294 
2295 typedef struct VkSparseImageOpaqueMemoryBindInfo {
2296     VkImage                      image;
2297     uint32_t                     bindCount;
2298     const VkSparseMemoryBind*    pBinds;
2299 } VkSparseImageOpaqueMemoryBindInfo;
2300 
2301 typedef struct VkImageSubresource {
2302     VkImageAspectFlags    aspectMask;
2303     uint32_t              mipLevel;
2304     uint32_t              arrayLayer;
2305 } VkImageSubresource;
2306 
2307 typedef struct VkOffset3D {
2308     int32_t    x;
2309     int32_t    y;
2310     int32_t    z;
2311 } VkOffset3D;
2312 
2313 typedef struct VkSparseImageMemoryBind {
2314     VkImageSubresource         subresource;
2315     VkOffset3D                 offset;
2316     VkExtent3D                 extent;
2317     VkDeviceMemory             memory;
2318     VkDeviceSize               memoryOffset;
2319     VkSparseMemoryBindFlags    flags;
2320 } VkSparseImageMemoryBind;
2321 
2322 typedef struct VkSparseImageMemoryBindInfo {
2323     VkImage                           image;
2324     uint32_t                          bindCount;
2325     const VkSparseImageMemoryBind*    pBinds;
2326 } VkSparseImageMemoryBindInfo;
2327 
2328 typedef struct VkBindSparseInfo {
2329     VkStructureType                             sType;
2330     const void*                                 pNext;
2331     uint32_t                                    waitSemaphoreCount;
2332     const VkSemaphore*                          pWaitSemaphores;
2333     uint32_t                                    bufferBindCount;
2334     const VkSparseBufferMemoryBindInfo*         pBufferBinds;
2335     uint32_t                                    imageOpaqueBindCount;
2336     const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
2337     uint32_t                                    imageBindCount;
2338     const VkSparseImageMemoryBindInfo*          pImageBinds;
2339     uint32_t                                    signalSemaphoreCount;
2340     const VkSemaphore*                          pSignalSemaphores;
2341 } VkBindSparseInfo;
2342 
2343 typedef struct VkFenceCreateInfo {
2344     VkStructureType       sType;
2345     const void*           pNext;
2346     VkFenceCreateFlags    flags;
2347 } VkFenceCreateInfo;
2348 
2349 typedef struct VkSemaphoreCreateInfo {
2350     VkStructureType           sType;
2351     const void*               pNext;
2352     VkSemaphoreCreateFlags    flags;
2353 } VkSemaphoreCreateInfo;
2354 
2355 typedef struct VkEventCreateInfo {
2356     VkStructureType       sType;
2357     const void*           pNext;
2358     VkEventCreateFlags    flags;
2359 } VkEventCreateInfo;
2360 
2361 typedef struct VkQueryPoolCreateInfo {
2362     VkStructureType                  sType;
2363     const void*                      pNext;
2364     VkQueryPoolCreateFlags           flags;
2365     VkQueryType                      queryType;
2366     uint32_t                         queryCount;
2367     VkQueryPipelineStatisticFlags    pipelineStatistics;
2368 } VkQueryPoolCreateInfo;
2369 
2370 typedef struct VkBufferCreateInfo {
2371     VkStructureType        sType;
2372     const void*            pNext;
2373     VkBufferCreateFlags    flags;
2374     VkDeviceSize           size;
2375     VkBufferUsageFlags     usage;
2376     VkSharingMode          sharingMode;
2377     uint32_t               queueFamilyIndexCount;
2378     const uint32_t*        pQueueFamilyIndices;
2379 } VkBufferCreateInfo;
2380 
2381 typedef struct VkBufferViewCreateInfo {
2382     VkStructureType            sType;
2383     const void*                pNext;
2384     VkBufferViewCreateFlags    flags;
2385     VkBuffer                   buffer;
2386     VkFormat                   format;
2387     VkDeviceSize               offset;
2388     VkDeviceSize               range;
2389 } VkBufferViewCreateInfo;
2390 
2391 typedef struct VkImageCreateInfo {
2392     VkStructureType          sType;
2393     const void*              pNext;
2394     VkImageCreateFlags       flags;
2395     VkImageType              imageType;
2396     VkFormat                 format;
2397     VkExtent3D               extent;
2398     uint32_t                 mipLevels;
2399     uint32_t                 arrayLayers;
2400     VkSampleCountFlagBits    samples;
2401     VkImageTiling            tiling;
2402     VkImageUsageFlags        usage;
2403     VkSharingMode            sharingMode;
2404     uint32_t                 queueFamilyIndexCount;
2405     const uint32_t*          pQueueFamilyIndices;
2406     VkImageLayout            initialLayout;
2407 } VkImageCreateInfo;
2408 
2409 typedef struct VkSubresourceLayout {
2410     VkDeviceSize    offset;
2411     VkDeviceSize    size;
2412     VkDeviceSize    rowPitch;
2413     VkDeviceSize    arrayPitch;
2414     VkDeviceSize    depthPitch;
2415 } VkSubresourceLayout;
2416 
2417 typedef struct VkComponentMapping {
2418     VkComponentSwizzle    r;
2419     VkComponentSwizzle    g;
2420     VkComponentSwizzle    b;
2421     VkComponentSwizzle    a;
2422 } VkComponentMapping;
2423 
2424 typedef struct VkImageSubresourceRange {
2425     VkImageAspectFlags    aspectMask;
2426     uint32_t              baseMipLevel;
2427     uint32_t              levelCount;
2428     uint32_t              baseArrayLayer;
2429     uint32_t              layerCount;
2430 } VkImageSubresourceRange;
2431 
2432 typedef struct VkImageViewCreateInfo {
2433     VkStructureType            sType;
2434     const void*                pNext;
2435     VkImageViewCreateFlags     flags;
2436     VkImage                    image;
2437     VkImageViewType            viewType;
2438     VkFormat                   format;
2439     VkComponentMapping         components;
2440     VkImageSubresourceRange    subresourceRange;
2441 } VkImageViewCreateInfo;
2442 
2443 typedef struct VkShaderModuleCreateInfo {
2444     VkStructureType              sType;
2445     const void*                  pNext;
2446     VkShaderModuleCreateFlags    flags;
2447     size_t                       codeSize;
2448     const uint32_t*              pCode;
2449 } VkShaderModuleCreateInfo;
2450 
2451 typedef struct VkPipelineCacheCreateInfo {
2452     VkStructureType               sType;
2453     const void*                   pNext;
2454     VkPipelineCacheCreateFlags    flags;
2455     size_t                        initialDataSize;
2456     const void*                   pInitialData;
2457 } VkPipelineCacheCreateInfo;
2458 
2459 typedef struct VkSpecializationMapEntry {
2460     uint32_t    constantID;
2461     uint32_t    offset;
2462     size_t      size;
2463 } VkSpecializationMapEntry;
2464 
2465 typedef struct VkSpecializationInfo {
2466     uint32_t                           mapEntryCount;
2467     const VkSpecializationMapEntry*    pMapEntries;
2468     size_t                             dataSize;
2469     const void*                        pData;
2470 } VkSpecializationInfo;
2471 
2472 typedef struct VkPipelineShaderStageCreateInfo {
2473     VkStructureType                     sType;
2474     const void*                         pNext;
2475     VkPipelineShaderStageCreateFlags    flags;
2476     VkShaderStageFlagBits               stage;
2477     VkShaderModule                      module;
2478     const char*                         pName;
2479     const VkSpecializationInfo*         pSpecializationInfo;
2480 } VkPipelineShaderStageCreateInfo;
2481 
2482 typedef struct VkVertexInputBindingDescription {
2483     uint32_t             binding;
2484     uint32_t             stride;
2485     VkVertexInputRate    inputRate;
2486 } VkVertexInputBindingDescription;
2487 
2488 typedef struct VkVertexInputAttributeDescription {
2489     uint32_t    location;
2490     uint32_t    binding;
2491     VkFormat    format;
2492     uint32_t    offset;
2493 } VkVertexInputAttributeDescription;
2494 
2495 typedef struct VkPipelineVertexInputStateCreateInfo {
2496     VkStructureType                             sType;
2497     const void*                                 pNext;
2498     VkPipelineVertexInputStateCreateFlags       flags;
2499     uint32_t                                    vertexBindingDescriptionCount;
2500     const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
2501     uint32_t                                    vertexAttributeDescriptionCount;
2502     const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
2503 } VkPipelineVertexInputStateCreateInfo;
2504 
2505 typedef struct VkPipelineInputAssemblyStateCreateInfo {
2506     VkStructureType                            sType;
2507     const void*                                pNext;
2508     VkPipelineInputAssemblyStateCreateFlags    flags;
2509     VkPrimitiveTopology                        topology;
2510     VkBool32                                   primitiveRestartEnable;
2511 } VkPipelineInputAssemblyStateCreateInfo;
2512 
2513 typedef struct VkPipelineTessellationStateCreateInfo {
2514     VkStructureType                           sType;
2515     const void*                               pNext;
2516     VkPipelineTessellationStateCreateFlags    flags;
2517     uint32_t                                  patchControlPoints;
2518 } VkPipelineTessellationStateCreateInfo;
2519 
2520 typedef struct VkViewport {
2521     float    x;
2522     float    y;
2523     float    width;
2524     float    height;
2525     float    minDepth;
2526     float    maxDepth;
2527 } VkViewport;
2528 
2529 typedef struct VkOffset2D {
2530     int32_t    x;
2531     int32_t    y;
2532 } VkOffset2D;
2533 
2534 typedef struct VkExtent2D {
2535     uint32_t    width;
2536     uint32_t    height;
2537 } VkExtent2D;
2538 
2539 typedef struct VkRect2D {
2540     VkOffset2D    offset;
2541     VkExtent2D    extent;
2542 } VkRect2D;
2543 
2544 typedef struct VkPipelineViewportStateCreateInfo {
2545     VkStructureType                       sType;
2546     const void*                           pNext;
2547     VkPipelineViewportStateCreateFlags    flags;
2548     uint32_t                              viewportCount;
2549     const VkViewport*                     pViewports;
2550     uint32_t                              scissorCount;
2551     const VkRect2D*                       pScissors;
2552 } VkPipelineViewportStateCreateInfo;
2553 
2554 typedef struct VkPipelineRasterizationStateCreateInfo {
2555     VkStructureType                            sType;
2556     const void*                                pNext;
2557     VkPipelineRasterizationStateCreateFlags    flags;
2558     VkBool32                                   depthClampEnable;
2559     VkBool32                                   rasterizerDiscardEnable;
2560     VkPolygonMode                              polygonMode;
2561     VkCullModeFlags                            cullMode;
2562     VkFrontFace                                frontFace;
2563     VkBool32                                   depthBiasEnable;
2564     float                                      depthBiasConstantFactor;
2565     float                                      depthBiasClamp;
2566     float                                      depthBiasSlopeFactor;
2567     float                                      lineWidth;
2568 } VkPipelineRasterizationStateCreateInfo;
2569 
2570 typedef struct VkPipelineMultisampleStateCreateInfo {
2571     VkStructureType                          sType;
2572     const void*                              pNext;
2573     VkPipelineMultisampleStateCreateFlags    flags;
2574     VkSampleCountFlagBits                    rasterizationSamples;
2575     VkBool32                                 sampleShadingEnable;
2576     float                                    minSampleShading;
2577     const VkSampleMask*                      pSampleMask;
2578     VkBool32                                 alphaToCoverageEnable;
2579     VkBool32                                 alphaToOneEnable;
2580 } VkPipelineMultisampleStateCreateInfo;
2581 
2582 typedef struct VkStencilOpState {
2583     VkStencilOp    failOp;
2584     VkStencilOp    passOp;
2585     VkStencilOp    depthFailOp;
2586     VkCompareOp    compareOp;
2587     uint32_t       compareMask;
2588     uint32_t       writeMask;
2589     uint32_t       reference;
2590 } VkStencilOpState;
2591 
2592 typedef struct VkPipelineDepthStencilStateCreateInfo {
2593     VkStructureType                           sType;
2594     const void*                               pNext;
2595     VkPipelineDepthStencilStateCreateFlags    flags;
2596     VkBool32                                  depthTestEnable;
2597     VkBool32                                  depthWriteEnable;
2598     VkCompareOp                               depthCompareOp;
2599     VkBool32                                  depthBoundsTestEnable;
2600     VkBool32                                  stencilTestEnable;
2601     VkStencilOpState                          front;
2602     VkStencilOpState                          back;
2603     float                                     minDepthBounds;
2604     float                                     maxDepthBounds;
2605 } VkPipelineDepthStencilStateCreateInfo;
2606 
2607 typedef struct VkPipelineColorBlendAttachmentState {
2608     VkBool32                 blendEnable;
2609     VkBlendFactor            srcColorBlendFactor;
2610     VkBlendFactor            dstColorBlendFactor;
2611     VkBlendOp                colorBlendOp;
2612     VkBlendFactor            srcAlphaBlendFactor;
2613     VkBlendFactor            dstAlphaBlendFactor;
2614     VkBlendOp                alphaBlendOp;
2615     VkColorComponentFlags    colorWriteMask;
2616 } VkPipelineColorBlendAttachmentState;
2617 
2618 typedef struct VkPipelineColorBlendStateCreateInfo {
2619     VkStructureType                               sType;
2620     const void*                                   pNext;
2621     VkPipelineColorBlendStateCreateFlags          flags;
2622     VkBool32                                      logicOpEnable;
2623     VkLogicOp                                     logicOp;
2624     uint32_t                                      attachmentCount;
2625     const VkPipelineColorBlendAttachmentState*    pAttachments;
2626     float                                         blendConstants[4];
2627 } VkPipelineColorBlendStateCreateInfo;
2628 
2629 typedef struct VkPipelineDynamicStateCreateInfo {
2630     VkStructureType                      sType;
2631     const void*                          pNext;
2632     VkPipelineDynamicStateCreateFlags    flags;
2633     uint32_t                             dynamicStateCount;
2634     const VkDynamicState*                pDynamicStates;
2635 } VkPipelineDynamicStateCreateInfo;
2636 
2637 typedef struct VkGraphicsPipelineCreateInfo {
2638     VkStructureType                                  sType;
2639     const void*                                      pNext;
2640     VkPipelineCreateFlags                            flags;
2641     uint32_t                                         stageCount;
2642     const VkPipelineShaderStageCreateInfo*           pStages;
2643     const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
2644     const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
2645     const VkPipelineTessellationStateCreateInfo*     pTessellationState;
2646     const VkPipelineViewportStateCreateInfo*         pViewportState;
2647     const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
2648     const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
2649     const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
2650     const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
2651     const VkPipelineDynamicStateCreateInfo*          pDynamicState;
2652     VkPipelineLayout                                 layout;
2653     VkRenderPass                                     renderPass;
2654     uint32_t                                         subpass;
2655     VkPipeline                                       basePipelineHandle;
2656     int32_t                                          basePipelineIndex;
2657 } VkGraphicsPipelineCreateInfo;
2658 
2659 typedef struct VkComputePipelineCreateInfo {
2660     VkStructureType                    sType;
2661     const void*                        pNext;
2662     VkPipelineCreateFlags              flags;
2663     VkPipelineShaderStageCreateInfo    stage;
2664     VkPipelineLayout                   layout;
2665     VkPipeline                         basePipelineHandle;
2666     int32_t                            basePipelineIndex;
2667 } VkComputePipelineCreateInfo;
2668 
2669 typedef struct VkPushConstantRange {
2670     VkShaderStageFlags    stageFlags;
2671     uint32_t              offset;
2672     uint32_t              size;
2673 } VkPushConstantRange;
2674 
2675 typedef struct VkPipelineLayoutCreateInfo {
2676     VkStructureType                 sType;
2677     const void*                     pNext;
2678     VkPipelineLayoutCreateFlags     flags;
2679     uint32_t                        setLayoutCount;
2680     const VkDescriptorSetLayout*    pSetLayouts;
2681     uint32_t                        pushConstantRangeCount;
2682     const VkPushConstantRange*      pPushConstantRanges;
2683 } VkPipelineLayoutCreateInfo;
2684 
2685 typedef struct VkSamplerCreateInfo {
2686     VkStructureType         sType;
2687     const void*             pNext;
2688     VkSamplerCreateFlags    flags;
2689     VkFilter                magFilter;
2690     VkFilter                minFilter;
2691     VkSamplerMipmapMode     mipmapMode;
2692     VkSamplerAddressMode    addressModeU;
2693     VkSamplerAddressMode    addressModeV;
2694     VkSamplerAddressMode    addressModeW;
2695     float                   mipLodBias;
2696     VkBool32                anisotropyEnable;
2697     float                   maxAnisotropy;
2698     VkBool32                compareEnable;
2699     VkCompareOp             compareOp;
2700     float                   minLod;
2701     float                   maxLod;
2702     VkBorderColor           borderColor;
2703     VkBool32                unnormalizedCoordinates;
2704 } VkSamplerCreateInfo;
2705 
2706 typedef struct VkDescriptorSetLayoutBinding {
2707     uint32_t              binding;
2708     VkDescriptorType      descriptorType;
2709     uint32_t              descriptorCount;
2710     VkShaderStageFlags    stageFlags;
2711     const VkSampler*      pImmutableSamplers;
2712 } VkDescriptorSetLayoutBinding;
2713 
2714 typedef struct VkDescriptorSetLayoutCreateInfo {
2715     VkStructureType                        sType;
2716     const void*                            pNext;
2717     VkDescriptorSetLayoutCreateFlags       flags;
2718     uint32_t                               bindingCount;
2719     const VkDescriptorSetLayoutBinding*    pBindings;
2720 } VkDescriptorSetLayoutCreateInfo;
2721 
2722 typedef struct VkDescriptorPoolSize {
2723     VkDescriptorType    type;
2724     uint32_t            descriptorCount;
2725 } VkDescriptorPoolSize;
2726 
2727 typedef struct VkDescriptorPoolCreateInfo {
2728     VkStructureType                sType;
2729     const void*                    pNext;
2730     VkDescriptorPoolCreateFlags    flags;
2731     uint32_t                       maxSets;
2732     uint32_t                       poolSizeCount;
2733     const VkDescriptorPoolSize*    pPoolSizes;
2734 } VkDescriptorPoolCreateInfo;
2735 
2736 typedef struct VkDescriptorSetAllocateInfo {
2737     VkStructureType                 sType;
2738     const void*                     pNext;
2739     VkDescriptorPool                descriptorPool;
2740     uint32_t                        descriptorSetCount;
2741     const VkDescriptorSetLayout*    pSetLayouts;
2742 } VkDescriptorSetAllocateInfo;
2743 
2744 typedef struct VkDescriptorImageInfo {
2745     VkSampler        sampler;
2746     VkImageView      imageView;
2747     VkImageLayout    imageLayout;
2748 } VkDescriptorImageInfo;
2749 
2750 typedef struct VkDescriptorBufferInfo {
2751     VkBuffer        buffer;
2752     VkDeviceSize    offset;
2753     VkDeviceSize    range;
2754 } VkDescriptorBufferInfo;
2755 
2756 typedef struct VkWriteDescriptorSet {
2757     VkStructureType                  sType;
2758     const void*                      pNext;
2759     VkDescriptorSet                  dstSet;
2760     uint32_t                         dstBinding;
2761     uint32_t                         dstArrayElement;
2762     uint32_t                         descriptorCount;
2763     VkDescriptorType                 descriptorType;
2764     const VkDescriptorImageInfo*     pImageInfo;
2765     const VkDescriptorBufferInfo*    pBufferInfo;
2766     const VkBufferView*              pTexelBufferView;
2767 } VkWriteDescriptorSet;
2768 
2769 typedef struct VkCopyDescriptorSet {
2770     VkStructureType    sType;
2771     const void*        pNext;
2772     VkDescriptorSet    srcSet;
2773     uint32_t           srcBinding;
2774     uint32_t           srcArrayElement;
2775     VkDescriptorSet    dstSet;
2776     uint32_t           dstBinding;
2777     uint32_t           dstArrayElement;
2778     uint32_t           descriptorCount;
2779 } VkCopyDescriptorSet;
2780 
2781 typedef struct VkFramebufferCreateInfo {
2782     VkStructureType             sType;
2783     const void*                 pNext;
2784     VkFramebufferCreateFlags    flags;
2785     VkRenderPass                renderPass;
2786     uint32_t                    attachmentCount;
2787     const VkImageView*          pAttachments;
2788     uint32_t                    width;
2789     uint32_t                    height;
2790     uint32_t                    layers;
2791 } VkFramebufferCreateInfo;
2792 
2793 typedef struct VkAttachmentDescription {
2794     VkAttachmentDescriptionFlags    flags;
2795     VkFormat                        format;
2796     VkSampleCountFlagBits           samples;
2797     VkAttachmentLoadOp              loadOp;
2798     VkAttachmentStoreOp             storeOp;
2799     VkAttachmentLoadOp              stencilLoadOp;
2800     VkAttachmentStoreOp             stencilStoreOp;
2801     VkImageLayout                   initialLayout;
2802     VkImageLayout                   finalLayout;
2803 } VkAttachmentDescription;
2804 
2805 typedef struct VkAttachmentReference {
2806     uint32_t         attachment;
2807     VkImageLayout    layout;
2808 } VkAttachmentReference;
2809 
2810 typedef struct VkSubpassDescription {
2811     VkSubpassDescriptionFlags       flags;
2812     VkPipelineBindPoint             pipelineBindPoint;
2813     uint32_t                        inputAttachmentCount;
2814     const VkAttachmentReference*    pInputAttachments;
2815     uint32_t                        colorAttachmentCount;
2816     const VkAttachmentReference*    pColorAttachments;
2817     const VkAttachmentReference*    pResolveAttachments;
2818     const VkAttachmentReference*    pDepthStencilAttachment;
2819     uint32_t                        preserveAttachmentCount;
2820     const uint32_t*                 pPreserveAttachments;
2821 } VkSubpassDescription;
2822 
2823 typedef struct VkSubpassDependency {
2824     uint32_t                srcSubpass;
2825     uint32_t                dstSubpass;
2826     VkPipelineStageFlags    srcStageMask;
2827     VkPipelineStageFlags    dstStageMask;
2828     VkAccessFlags           srcAccessMask;
2829     VkAccessFlags           dstAccessMask;
2830     VkDependencyFlags       dependencyFlags;
2831 } VkSubpassDependency;
2832 
2833 typedef struct VkRenderPassCreateInfo {
2834     VkStructureType                   sType;
2835     const void*                       pNext;
2836     VkRenderPassCreateFlags           flags;
2837     uint32_t                          attachmentCount;
2838     const VkAttachmentDescription*    pAttachments;
2839     uint32_t                          subpassCount;
2840     const VkSubpassDescription*       pSubpasses;
2841     uint32_t                          dependencyCount;
2842     const VkSubpassDependency*        pDependencies;
2843 } VkRenderPassCreateInfo;
2844 
2845 typedef struct VkCommandPoolCreateInfo {
2846     VkStructureType             sType;
2847     const void*                 pNext;
2848     VkCommandPoolCreateFlags    flags;
2849     uint32_t                    queueFamilyIndex;
2850 } VkCommandPoolCreateInfo;
2851 
2852 typedef struct VkCommandBufferAllocateInfo {
2853     VkStructureType         sType;
2854     const void*             pNext;
2855     VkCommandPool           commandPool;
2856     VkCommandBufferLevel    level;
2857     uint32_t                commandBufferCount;
2858 } VkCommandBufferAllocateInfo;
2859 
2860 typedef struct VkCommandBufferInheritanceInfo {
2861     VkStructureType                  sType;
2862     const void*                      pNext;
2863     VkRenderPass                     renderPass;
2864     uint32_t                         subpass;
2865     VkFramebuffer                    framebuffer;
2866     VkBool32                         occlusionQueryEnable;
2867     VkQueryControlFlags              queryFlags;
2868     VkQueryPipelineStatisticFlags    pipelineStatistics;
2869 } VkCommandBufferInheritanceInfo;
2870 
2871 typedef struct VkCommandBufferBeginInfo {
2872     VkStructureType                          sType;
2873     const void*                              pNext;
2874     VkCommandBufferUsageFlags                flags;
2875     const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
2876 } VkCommandBufferBeginInfo;
2877 
2878 typedef struct VkBufferCopy {
2879     VkDeviceSize    srcOffset;
2880     VkDeviceSize    dstOffset;
2881     VkDeviceSize    size;
2882 } VkBufferCopy;
2883 
2884 typedef struct VkImageSubresourceLayers {
2885     VkImageAspectFlags    aspectMask;
2886     uint32_t              mipLevel;
2887     uint32_t              baseArrayLayer;
2888     uint32_t              layerCount;
2889 } VkImageSubresourceLayers;
2890 
2891 typedef struct VkImageCopy {
2892     VkImageSubresourceLayers    srcSubresource;
2893     VkOffset3D                  srcOffset;
2894     VkImageSubresourceLayers    dstSubresource;
2895     VkOffset3D                  dstOffset;
2896     VkExtent3D                  extent;
2897 } VkImageCopy;
2898 
2899 typedef struct VkImageBlit {
2900     VkImageSubresourceLayers    srcSubresource;
2901     VkOffset3D                  srcOffsets[2];
2902     VkImageSubresourceLayers    dstSubresource;
2903     VkOffset3D                  dstOffsets[2];
2904 } VkImageBlit;
2905 
2906 typedef struct VkBufferImageCopy {
2907     VkDeviceSize                bufferOffset;
2908     uint32_t                    bufferRowLength;
2909     uint32_t                    bufferImageHeight;
2910     VkImageSubresourceLayers    imageSubresource;
2911     VkOffset3D                  imageOffset;
2912     VkExtent3D                  imageExtent;
2913 } VkBufferImageCopy;
2914 
2915 typedef union VkClearColorValue {
2916     float       float32[4];
2917     int32_t     int32[4];
2918     uint32_t    uint32[4];
2919 } VkClearColorValue;
2920 
2921 typedef struct VkClearDepthStencilValue {
2922     float       depth;
2923     uint32_t    stencil;
2924 } VkClearDepthStencilValue;
2925 
2926 typedef union VkClearValue {
2927     VkClearColorValue           color;
2928     VkClearDepthStencilValue    depthStencil;
2929 } VkClearValue;
2930 
2931 typedef struct VkClearAttachment {
2932     VkImageAspectFlags    aspectMask;
2933     uint32_t              colorAttachment;
2934     VkClearValue          clearValue;
2935 } VkClearAttachment;
2936 
2937 typedef struct VkClearRect {
2938     VkRect2D    rect;
2939     uint32_t    baseArrayLayer;
2940     uint32_t    layerCount;
2941 } VkClearRect;
2942 
2943 typedef struct VkImageResolve {
2944     VkImageSubresourceLayers    srcSubresource;
2945     VkOffset3D                  srcOffset;
2946     VkImageSubresourceLayers    dstSubresource;
2947     VkOffset3D                  dstOffset;
2948     VkExtent3D                  extent;
2949 } VkImageResolve;
2950 
2951 typedef struct VkMemoryBarrier {
2952     VkStructureType    sType;
2953     const void*        pNext;
2954     VkAccessFlags      srcAccessMask;
2955     VkAccessFlags      dstAccessMask;
2956 } VkMemoryBarrier;
2957 
2958 typedef struct VkBufferMemoryBarrier {
2959     VkStructureType    sType;
2960     const void*        pNext;
2961     VkAccessFlags      srcAccessMask;
2962     VkAccessFlags      dstAccessMask;
2963     uint32_t           srcQueueFamilyIndex;
2964     uint32_t           dstQueueFamilyIndex;
2965     VkBuffer           buffer;
2966     VkDeviceSize       offset;
2967     VkDeviceSize       size;
2968 } VkBufferMemoryBarrier;
2969 
2970 typedef struct VkImageMemoryBarrier {
2971     VkStructureType            sType;
2972     const void*                pNext;
2973     VkAccessFlags              srcAccessMask;
2974     VkAccessFlags              dstAccessMask;
2975     VkImageLayout              oldLayout;
2976     VkImageLayout              newLayout;
2977     uint32_t                   srcQueueFamilyIndex;
2978     uint32_t                   dstQueueFamilyIndex;
2979     VkImage                    image;
2980     VkImageSubresourceRange    subresourceRange;
2981 } VkImageMemoryBarrier;
2982 
2983 typedef struct VkRenderPassBeginInfo {
2984     VkStructureType        sType;
2985     const void*            pNext;
2986     VkRenderPass           renderPass;
2987     VkFramebuffer          framebuffer;
2988     VkRect2D               renderArea;
2989     uint32_t               clearValueCount;
2990     const VkClearValue*    pClearValues;
2991 } VkRenderPassBeginInfo;
2992 
2993 typedef struct VkDispatchIndirectCommand {
2994     uint32_t    x;
2995     uint32_t    y;
2996     uint32_t    z;
2997 } VkDispatchIndirectCommand;
2998 
2999 typedef struct VkDrawIndexedIndirectCommand {
3000     uint32_t    indexCount;
3001     uint32_t    instanceCount;
3002     uint32_t    firstIndex;
3003     int32_t     vertexOffset;
3004     uint32_t    firstInstance;
3005 } VkDrawIndexedIndirectCommand;
3006 
3007 typedef struct VkDrawIndirectCommand {
3008     uint32_t    vertexCount;
3009     uint32_t    instanceCount;
3010     uint32_t    firstVertex;
3011     uint32_t    firstInstance;
3012 } VkDrawIndirectCommand;
3013 
3014 typedef struct VkBaseOutStructure {
3015     VkStructureType               sType;
3016     struct VkBaseOutStructure*    pNext;
3017 } VkBaseOutStructure;
3018 
3019 typedef struct VkBaseInStructure {
3020     VkStructureType                    sType;
3021     const struct VkBaseInStructure*    pNext;
3022 } VkBaseInStructure;
3023 
3024 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
3025 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
3026 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
3027 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
3028 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
3029 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
3030 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
3031 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
3032 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
3033 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
3034 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
3035 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
3036 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
3037 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
3038 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
3039 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
3040 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
3041 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
3042 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
3043 typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
3044 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
3045 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
3046 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
3047 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
3048 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
3049 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3050 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3051 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
3052 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3053 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3054 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
3055 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
3056 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
3057 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
3058 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
3059 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
3060 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
3061 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
3062 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
3063 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
3064 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
3065 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
3066 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
3067 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
3068 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
3069 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
3070 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
3071 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
3072 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
3073 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);
3074 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
3075 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
3076 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
3077 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
3078 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
3079 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
3080 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
3081 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
3082 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
3083 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
3084 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
3085 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
3086 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
3087 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
3088 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
3089 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3090 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3091 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
3092 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
3093 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
3094 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
3095 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
3096 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
3097 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
3098 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
3099 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
3100 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
3101 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
3102 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
3103 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
3104 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
3105 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
3106 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
3107 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
3108 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
3109 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
3110 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
3111 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
3112 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
3113 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3114 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
3115 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
3116 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
3117 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
3118 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
3119 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
3120 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
3121 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
3122 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
3123 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
3124 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
3125 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
3126 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
3127 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);
3128 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
3129 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
3130 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
3131 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
3132 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3133 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
3134 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
3135 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
3136 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
3137 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
3138 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
3139 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3140 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
3141 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
3142 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
3143 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3144 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
3145 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
3146 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
3147 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3148 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
3149 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);
3150 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);
3151 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
3152 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
3153 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
3154 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
3155 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
3156 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
3157 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
3158 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
3159 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
3160 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3161 
3162 #ifndef VK_NO_PROTOTYPES
3163 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
3164     const VkInstanceCreateInfo*                 pCreateInfo,
3165     const VkAllocationCallbacks*                pAllocator,
3166     VkInstance*                                 pInstance);
3167 
3168 VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
3169     VkInstance                                  instance,
3170     const VkAllocationCallbacks*                pAllocator);
3171 
3172 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
3173     VkInstance                                  instance,
3174     uint32_t*                                   pPhysicalDeviceCount,
3175     VkPhysicalDevice*                           pPhysicalDevices);
3176 
3177 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
3178     VkPhysicalDevice                            physicalDevice,
3179     VkPhysicalDeviceFeatures*                   pFeatures);
3180 
3181 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
3182     VkPhysicalDevice                            physicalDevice,
3183     VkFormat                                    format,
3184     VkFormatProperties*                         pFormatProperties);
3185 
3186 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
3187     VkPhysicalDevice                            physicalDevice,
3188     VkFormat                                    format,
3189     VkImageType                                 type,
3190     VkImageTiling                               tiling,
3191     VkImageUsageFlags                           usage,
3192     VkImageCreateFlags                          flags,
3193     VkImageFormatProperties*                    pImageFormatProperties);
3194 
3195 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
3196     VkPhysicalDevice                            physicalDevice,
3197     VkPhysicalDeviceProperties*                 pProperties);
3198 
3199 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
3200     VkPhysicalDevice                            physicalDevice,
3201     uint32_t*                                   pQueueFamilyPropertyCount,
3202     VkQueueFamilyProperties*                    pQueueFamilyProperties);
3203 
3204 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
3205     VkPhysicalDevice                            physicalDevice,
3206     VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
3207 
3208 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
3209     VkInstance                                  instance,
3210     const char*                                 pName);
3211 
3212 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
3213     VkDevice                                    device,
3214     const char*                                 pName);
3215 
3216 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
3217     VkPhysicalDevice                            physicalDevice,
3218     const VkDeviceCreateInfo*                   pCreateInfo,
3219     const VkAllocationCallbacks*                pAllocator,
3220     VkDevice*                                   pDevice);
3221 
3222 VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
3223     VkDevice                                    device,
3224     const VkAllocationCallbacks*                pAllocator);
3225 
3226 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
3227     const char*                                 pLayerName,
3228     uint32_t*                                   pPropertyCount,
3229     VkExtensionProperties*                      pProperties);
3230 
3231 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
3232     VkPhysicalDevice                            physicalDevice,
3233     const char*                                 pLayerName,
3234     uint32_t*                                   pPropertyCount,
3235     VkExtensionProperties*                      pProperties);
3236 
3237 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
3238     uint32_t*                                   pPropertyCount,
3239     VkLayerProperties*                          pProperties);
3240 
3241 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
3242     VkPhysicalDevice                            physicalDevice,
3243     uint32_t*                                   pPropertyCount,
3244     VkLayerProperties*                          pProperties);
3245 
3246 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
3247     VkDevice                                    device,
3248     uint32_t                                    queueFamilyIndex,
3249     uint32_t                                    queueIndex,
3250     VkQueue*                                    pQueue);
3251 
3252 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
3253     VkQueue                                     queue,
3254     uint32_t                                    submitCount,
3255     const VkSubmitInfo*                         pSubmits,
3256     VkFence                                     fence);
3257 
3258 VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
3259     VkQueue                                     queue);
3260 
3261 VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
3262     VkDevice                                    device);
3263 
3264 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
3265     VkDevice                                    device,
3266     const VkMemoryAllocateInfo*                 pAllocateInfo,
3267     const VkAllocationCallbacks*                pAllocator,
3268     VkDeviceMemory*                             pMemory);
3269 
3270 VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
3271     VkDevice                                    device,
3272     VkDeviceMemory                              memory,
3273     const VkAllocationCallbacks*                pAllocator);
3274 
3275 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
3276     VkDevice                                    device,
3277     VkDeviceMemory                              memory,
3278     VkDeviceSize                                offset,
3279     VkDeviceSize                                size,
3280     VkMemoryMapFlags                            flags,
3281     void**                                      ppData);
3282 
3283 VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
3284     VkDevice                                    device,
3285     VkDeviceMemory                              memory);
3286 
3287 VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
3288     VkDevice                                    device,
3289     uint32_t                                    memoryRangeCount,
3290     const VkMappedMemoryRange*                  pMemoryRanges);
3291 
3292 VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
3293     VkDevice                                    device,
3294     uint32_t                                    memoryRangeCount,
3295     const VkMappedMemoryRange*                  pMemoryRanges);
3296 
3297 VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
3298     VkDevice                                    device,
3299     VkDeviceMemory                              memory,
3300     VkDeviceSize*                               pCommittedMemoryInBytes);
3301 
3302 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
3303     VkDevice                                    device,
3304     VkBuffer                                    buffer,
3305     VkDeviceMemory                              memory,
3306     VkDeviceSize                                memoryOffset);
3307 
3308 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
3309     VkDevice                                    device,
3310     VkImage                                     image,
3311     VkDeviceMemory                              memory,
3312     VkDeviceSize                                memoryOffset);
3313 
3314 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
3315     VkDevice                                    device,
3316     VkBuffer                                    buffer,
3317     VkMemoryRequirements*                       pMemoryRequirements);
3318 
3319 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
3320     VkDevice                                    device,
3321     VkImage                                     image,
3322     VkMemoryRequirements*                       pMemoryRequirements);
3323 
3324 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
3325     VkDevice                                    device,
3326     VkImage                                     image,
3327     uint32_t*                                   pSparseMemoryRequirementCount,
3328     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
3329 
3330 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
3331     VkPhysicalDevice                            physicalDevice,
3332     VkFormat                                    format,
3333     VkImageType                                 type,
3334     VkSampleCountFlagBits                       samples,
3335     VkImageUsageFlags                           usage,
3336     VkImageTiling                               tiling,
3337     uint32_t*                                   pPropertyCount,
3338     VkSparseImageFormatProperties*              pProperties);
3339 
3340 VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
3341     VkQueue                                     queue,
3342     uint32_t                                    bindInfoCount,
3343     const VkBindSparseInfo*                     pBindInfo,
3344     VkFence                                     fence);
3345 
3346 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
3347     VkDevice                                    device,
3348     const VkFenceCreateInfo*                    pCreateInfo,
3349     const VkAllocationCallbacks*                pAllocator,
3350     VkFence*                                    pFence);
3351 
3352 VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
3353     VkDevice                                    device,
3354     VkFence                                     fence,
3355     const VkAllocationCallbacks*                pAllocator);
3356 
3357 VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
3358     VkDevice                                    device,
3359     uint32_t                                    fenceCount,
3360     const VkFence*                              pFences);
3361 
3362 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
3363     VkDevice                                    device,
3364     VkFence                                     fence);
3365 
3366 VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
3367     VkDevice                                    device,
3368     uint32_t                                    fenceCount,
3369     const VkFence*                              pFences,
3370     VkBool32                                    waitAll,
3371     uint64_t                                    timeout);
3372 
3373 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
3374     VkDevice                                    device,
3375     const VkSemaphoreCreateInfo*                pCreateInfo,
3376     const VkAllocationCallbacks*                pAllocator,
3377     VkSemaphore*                                pSemaphore);
3378 
3379 VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
3380     VkDevice                                    device,
3381     VkSemaphore                                 semaphore,
3382     const VkAllocationCallbacks*                pAllocator);
3383 
3384 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
3385     VkDevice                                    device,
3386     const VkEventCreateInfo*                    pCreateInfo,
3387     const VkAllocationCallbacks*                pAllocator,
3388     VkEvent*                                    pEvent);
3389 
3390 VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
3391     VkDevice                                    device,
3392     VkEvent                                     event,
3393     const VkAllocationCallbacks*                pAllocator);
3394 
3395 VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
3396     VkDevice                                    device,
3397     VkEvent                                     event);
3398 
3399 VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
3400     VkDevice                                    device,
3401     VkEvent                                     event);
3402 
3403 VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
3404     VkDevice                                    device,
3405     VkEvent                                     event);
3406 
3407 VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
3408     VkDevice                                    device,
3409     const VkQueryPoolCreateInfo*                pCreateInfo,
3410     const VkAllocationCallbacks*                pAllocator,
3411     VkQueryPool*                                pQueryPool);
3412 
3413 VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
3414     VkDevice                                    device,
3415     VkQueryPool                                 queryPool,
3416     const VkAllocationCallbacks*                pAllocator);
3417 
3418 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
3419     VkDevice                                    device,
3420     VkQueryPool                                 queryPool,
3421     uint32_t                                    firstQuery,
3422     uint32_t                                    queryCount,
3423     size_t                                      dataSize,
3424     void*                                       pData,
3425     VkDeviceSize                                stride,
3426     VkQueryResultFlags                          flags);
3427 
3428 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
3429     VkDevice                                    device,
3430     const VkBufferCreateInfo*                   pCreateInfo,
3431     const VkAllocationCallbacks*                pAllocator,
3432     VkBuffer*                                   pBuffer);
3433 
3434 VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
3435     VkDevice                                    device,
3436     VkBuffer                                    buffer,
3437     const VkAllocationCallbacks*                pAllocator);
3438 
3439 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
3440     VkDevice                                    device,
3441     const VkBufferViewCreateInfo*               pCreateInfo,
3442     const VkAllocationCallbacks*                pAllocator,
3443     VkBufferView*                               pView);
3444 
3445 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
3446     VkDevice                                    device,
3447     VkBufferView                                bufferView,
3448     const VkAllocationCallbacks*                pAllocator);
3449 
3450 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
3451     VkDevice                                    device,
3452     const VkImageCreateInfo*                    pCreateInfo,
3453     const VkAllocationCallbacks*                pAllocator,
3454     VkImage*                                    pImage);
3455 
3456 VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
3457     VkDevice                                    device,
3458     VkImage                                     image,
3459     const VkAllocationCallbacks*                pAllocator);
3460 
3461 VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
3462     VkDevice                                    device,
3463     VkImage                                     image,
3464     const VkImageSubresource*                   pSubresource,
3465     VkSubresourceLayout*                        pLayout);
3466 
3467 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
3468     VkDevice                                    device,
3469     const VkImageViewCreateInfo*                pCreateInfo,
3470     const VkAllocationCallbacks*                pAllocator,
3471     VkImageView*                                pView);
3472 
3473 VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
3474     VkDevice                                    device,
3475     VkImageView                                 imageView,
3476     const VkAllocationCallbacks*                pAllocator);
3477 
3478 VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
3479     VkDevice                                    device,
3480     const VkShaderModuleCreateInfo*             pCreateInfo,
3481     const VkAllocationCallbacks*                pAllocator,
3482     VkShaderModule*                             pShaderModule);
3483 
3484 VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
3485     VkDevice                                    device,
3486     VkShaderModule                              shaderModule,
3487     const VkAllocationCallbacks*                pAllocator);
3488 
3489 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
3490     VkDevice                                    device,
3491     const VkPipelineCacheCreateInfo*            pCreateInfo,
3492     const VkAllocationCallbacks*                pAllocator,
3493     VkPipelineCache*                            pPipelineCache);
3494 
3495 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
3496     VkDevice                                    device,
3497     VkPipelineCache                             pipelineCache,
3498     const VkAllocationCallbacks*                pAllocator);
3499 
3500 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
3501     VkDevice                                    device,
3502     VkPipelineCache                             pipelineCache,
3503     size_t*                                     pDataSize,
3504     void*                                       pData);
3505 
3506 VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
3507     VkDevice                                    device,
3508     VkPipelineCache                             dstCache,
3509     uint32_t                                    srcCacheCount,
3510     const VkPipelineCache*                      pSrcCaches);
3511 
3512 VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
3513     VkDevice                                    device,
3514     VkPipelineCache                             pipelineCache,
3515     uint32_t                                    createInfoCount,
3516     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
3517     const VkAllocationCallbacks*                pAllocator,
3518     VkPipeline*                                 pPipelines);
3519 
3520 VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
3521     VkDevice                                    device,
3522     VkPipelineCache                             pipelineCache,
3523     uint32_t                                    createInfoCount,
3524     const VkComputePipelineCreateInfo*          pCreateInfos,
3525     const VkAllocationCallbacks*                pAllocator,
3526     VkPipeline*                                 pPipelines);
3527 
3528 VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
3529     VkDevice                                    device,
3530     VkPipeline                                  pipeline,
3531     const VkAllocationCallbacks*                pAllocator);
3532 
3533 VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
3534     VkDevice                                    device,
3535     const VkPipelineLayoutCreateInfo*           pCreateInfo,
3536     const VkAllocationCallbacks*                pAllocator,
3537     VkPipelineLayout*                           pPipelineLayout);
3538 
3539 VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
3540     VkDevice                                    device,
3541     VkPipelineLayout                            pipelineLayout,
3542     const VkAllocationCallbacks*                pAllocator);
3543 
3544 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
3545     VkDevice                                    device,
3546     const VkSamplerCreateInfo*                  pCreateInfo,
3547     const VkAllocationCallbacks*                pAllocator,
3548     VkSampler*                                  pSampler);
3549 
3550 VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
3551     VkDevice                                    device,
3552     VkSampler                                   sampler,
3553     const VkAllocationCallbacks*                pAllocator);
3554 
3555 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
3556     VkDevice                                    device,
3557     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
3558     const VkAllocationCallbacks*                pAllocator,
3559     VkDescriptorSetLayout*                      pSetLayout);
3560 
3561 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
3562     VkDevice                                    device,
3563     VkDescriptorSetLayout                       descriptorSetLayout,
3564     const VkAllocationCallbacks*                pAllocator);
3565 
3566 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
3567     VkDevice                                    device,
3568     const VkDescriptorPoolCreateInfo*           pCreateInfo,
3569     const VkAllocationCallbacks*                pAllocator,
3570     VkDescriptorPool*                           pDescriptorPool);
3571 
3572 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
3573     VkDevice                                    device,
3574     VkDescriptorPool                            descriptorPool,
3575     const VkAllocationCallbacks*                pAllocator);
3576 
3577 VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
3578     VkDevice                                    device,
3579     VkDescriptorPool                            descriptorPool,
3580     VkDescriptorPoolResetFlags                  flags);
3581 
3582 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
3583     VkDevice                                    device,
3584     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
3585     VkDescriptorSet*                            pDescriptorSets);
3586 
3587 VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
3588     VkDevice                                    device,
3589     VkDescriptorPool                            descriptorPool,
3590     uint32_t                                    descriptorSetCount,
3591     const VkDescriptorSet*                      pDescriptorSets);
3592 
3593 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
3594     VkDevice                                    device,
3595     uint32_t                                    descriptorWriteCount,
3596     const VkWriteDescriptorSet*                 pDescriptorWrites,
3597     uint32_t                                    descriptorCopyCount,
3598     const VkCopyDescriptorSet*                  pDescriptorCopies);
3599 
3600 VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
3601     VkDevice                                    device,
3602     const VkFramebufferCreateInfo*              pCreateInfo,
3603     const VkAllocationCallbacks*                pAllocator,
3604     VkFramebuffer*                              pFramebuffer);
3605 
3606 VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
3607     VkDevice                                    device,
3608     VkFramebuffer                               framebuffer,
3609     const VkAllocationCallbacks*                pAllocator);
3610 
3611 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
3612     VkDevice                                    device,
3613     const VkRenderPassCreateInfo*               pCreateInfo,
3614     const VkAllocationCallbacks*                pAllocator,
3615     VkRenderPass*                               pRenderPass);
3616 
3617 VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
3618     VkDevice                                    device,
3619     VkRenderPass                                renderPass,
3620     const VkAllocationCallbacks*                pAllocator);
3621 
3622 VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
3623     VkDevice                                    device,
3624     VkRenderPass                                renderPass,
3625     VkExtent2D*                                 pGranularity);
3626 
3627 VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
3628     VkDevice                                    device,
3629     const VkCommandPoolCreateInfo*              pCreateInfo,
3630     const VkAllocationCallbacks*                pAllocator,
3631     VkCommandPool*                              pCommandPool);
3632 
3633 VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
3634     VkDevice                                    device,
3635     VkCommandPool                               commandPool,
3636     const VkAllocationCallbacks*                pAllocator);
3637 
3638 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
3639     VkDevice                                    device,
3640     VkCommandPool                               commandPool,
3641     VkCommandPoolResetFlags                     flags);
3642 
3643 VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
3644     VkDevice                                    device,
3645     const VkCommandBufferAllocateInfo*          pAllocateInfo,
3646     VkCommandBuffer*                            pCommandBuffers);
3647 
3648 VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
3649     VkDevice                                    device,
3650     VkCommandPool                               commandPool,
3651     uint32_t                                    commandBufferCount,
3652     const VkCommandBuffer*                      pCommandBuffers);
3653 
3654 VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
3655     VkCommandBuffer                             commandBuffer,
3656     const VkCommandBufferBeginInfo*             pBeginInfo);
3657 
3658 VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
3659     VkCommandBuffer                             commandBuffer);
3660 
3661 VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
3662     VkCommandBuffer                             commandBuffer,
3663     VkCommandBufferResetFlags                   flags);
3664 
3665 VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
3666     VkCommandBuffer                             commandBuffer,
3667     VkPipelineBindPoint                         pipelineBindPoint,
3668     VkPipeline                                  pipeline);
3669 
3670 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
3671     VkCommandBuffer                             commandBuffer,
3672     uint32_t                                    firstViewport,
3673     uint32_t                                    viewportCount,
3674     const VkViewport*                           pViewports);
3675 
3676 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
3677     VkCommandBuffer                             commandBuffer,
3678     uint32_t                                    firstScissor,
3679     uint32_t                                    scissorCount,
3680     const VkRect2D*                             pScissors);
3681 
3682 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
3683     VkCommandBuffer                             commandBuffer,
3684     float                                       lineWidth);
3685 
3686 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
3687     VkCommandBuffer                             commandBuffer,
3688     float                                       depthBiasConstantFactor,
3689     float                                       depthBiasClamp,
3690     float                                       depthBiasSlopeFactor);
3691 
3692 VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
3693     VkCommandBuffer                             commandBuffer,
3694     const float                                 blendConstants[4]);
3695 
3696 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
3697     VkCommandBuffer                             commandBuffer,
3698     float                                       minDepthBounds,
3699     float                                       maxDepthBounds);
3700 
3701 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
3702     VkCommandBuffer                             commandBuffer,
3703     VkStencilFaceFlags                          faceMask,
3704     uint32_t                                    compareMask);
3705 
3706 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
3707     VkCommandBuffer                             commandBuffer,
3708     VkStencilFaceFlags                          faceMask,
3709     uint32_t                                    writeMask);
3710 
3711 VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
3712     VkCommandBuffer                             commandBuffer,
3713     VkStencilFaceFlags                          faceMask,
3714     uint32_t                                    reference);
3715 
3716 VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
3717     VkCommandBuffer                             commandBuffer,
3718     VkPipelineBindPoint                         pipelineBindPoint,
3719     VkPipelineLayout                            layout,
3720     uint32_t                                    firstSet,
3721     uint32_t                                    descriptorSetCount,
3722     const VkDescriptorSet*                      pDescriptorSets,
3723     uint32_t                                    dynamicOffsetCount,
3724     const uint32_t*                             pDynamicOffsets);
3725 
3726 VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
3727     VkCommandBuffer                             commandBuffer,
3728     VkBuffer                                    buffer,
3729     VkDeviceSize                                offset,
3730     VkIndexType                                 indexType);
3731 
3732 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
3733     VkCommandBuffer                             commandBuffer,
3734     uint32_t                                    firstBinding,
3735     uint32_t                                    bindingCount,
3736     const VkBuffer*                             pBuffers,
3737     const VkDeviceSize*                         pOffsets);
3738 
3739 VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
3740     VkCommandBuffer                             commandBuffer,
3741     uint32_t                                    vertexCount,
3742     uint32_t                                    instanceCount,
3743     uint32_t                                    firstVertex,
3744     uint32_t                                    firstInstance);
3745 
3746 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
3747     VkCommandBuffer                             commandBuffer,
3748     uint32_t                                    indexCount,
3749     uint32_t                                    instanceCount,
3750     uint32_t                                    firstIndex,
3751     int32_t                                     vertexOffset,
3752     uint32_t                                    firstInstance);
3753 
3754 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
3755     VkCommandBuffer                             commandBuffer,
3756     VkBuffer                                    buffer,
3757     VkDeviceSize                                offset,
3758     uint32_t                                    drawCount,
3759     uint32_t                                    stride);
3760 
3761 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
3762     VkCommandBuffer                             commandBuffer,
3763     VkBuffer                                    buffer,
3764     VkDeviceSize                                offset,
3765     uint32_t                                    drawCount,
3766     uint32_t                                    stride);
3767 
3768 VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
3769     VkCommandBuffer                             commandBuffer,
3770     uint32_t                                    groupCountX,
3771     uint32_t                                    groupCountY,
3772     uint32_t                                    groupCountZ);
3773 
3774 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
3775     VkCommandBuffer                             commandBuffer,
3776     VkBuffer                                    buffer,
3777     VkDeviceSize                                offset);
3778 
3779 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
3780     VkCommandBuffer                             commandBuffer,
3781     VkBuffer                                    srcBuffer,
3782     VkBuffer                                    dstBuffer,
3783     uint32_t                                    regionCount,
3784     const VkBufferCopy*                         pRegions);
3785 
3786 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
3787     VkCommandBuffer                             commandBuffer,
3788     VkImage                                     srcImage,
3789     VkImageLayout                               srcImageLayout,
3790     VkImage                                     dstImage,
3791     VkImageLayout                               dstImageLayout,
3792     uint32_t                                    regionCount,
3793     const VkImageCopy*                          pRegions);
3794 
3795 VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
3796     VkCommandBuffer                             commandBuffer,
3797     VkImage                                     srcImage,
3798     VkImageLayout                               srcImageLayout,
3799     VkImage                                     dstImage,
3800     VkImageLayout                               dstImageLayout,
3801     uint32_t                                    regionCount,
3802     const VkImageBlit*                          pRegions,
3803     VkFilter                                    filter);
3804 
3805 VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
3806     VkCommandBuffer                             commandBuffer,
3807     VkBuffer                                    srcBuffer,
3808     VkImage                                     dstImage,
3809     VkImageLayout                               dstImageLayout,
3810     uint32_t                                    regionCount,
3811     const VkBufferImageCopy*                    pRegions);
3812 
3813 VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
3814     VkCommandBuffer                             commandBuffer,
3815     VkImage                                     srcImage,
3816     VkImageLayout                               srcImageLayout,
3817     VkBuffer                                    dstBuffer,
3818     uint32_t                                    regionCount,
3819     const VkBufferImageCopy*                    pRegions);
3820 
3821 VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
3822     VkCommandBuffer                             commandBuffer,
3823     VkBuffer                                    dstBuffer,
3824     VkDeviceSize                                dstOffset,
3825     VkDeviceSize                                dataSize,
3826     const void*                                 pData);
3827 
3828 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
3829     VkCommandBuffer                             commandBuffer,
3830     VkBuffer                                    dstBuffer,
3831     VkDeviceSize                                dstOffset,
3832     VkDeviceSize                                size,
3833     uint32_t                                    data);
3834 
3835 VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
3836     VkCommandBuffer                             commandBuffer,
3837     VkImage                                     image,
3838     VkImageLayout                               imageLayout,
3839     const VkClearColorValue*                    pColor,
3840     uint32_t                                    rangeCount,
3841     const VkImageSubresourceRange*              pRanges);
3842 
3843 VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
3844     VkCommandBuffer                             commandBuffer,
3845     VkImage                                     image,
3846     VkImageLayout                               imageLayout,
3847     const VkClearDepthStencilValue*             pDepthStencil,
3848     uint32_t                                    rangeCount,
3849     const VkImageSubresourceRange*              pRanges);
3850 
3851 VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
3852     VkCommandBuffer                             commandBuffer,
3853     uint32_t                                    attachmentCount,
3854     const VkClearAttachment*                    pAttachments,
3855     uint32_t                                    rectCount,
3856     const VkClearRect*                          pRects);
3857 
3858 VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
3859     VkCommandBuffer                             commandBuffer,
3860     VkImage                                     srcImage,
3861     VkImageLayout                               srcImageLayout,
3862     VkImage                                     dstImage,
3863     VkImageLayout                               dstImageLayout,
3864     uint32_t                                    regionCount,
3865     const VkImageResolve*                       pRegions);
3866 
3867 VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
3868     VkCommandBuffer                             commandBuffer,
3869     VkEvent                                     event,
3870     VkPipelineStageFlags                        stageMask);
3871 
3872 VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
3873     VkCommandBuffer                             commandBuffer,
3874     VkEvent                                     event,
3875     VkPipelineStageFlags                        stageMask);
3876 
3877 VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
3878     VkCommandBuffer                             commandBuffer,
3879     uint32_t                                    eventCount,
3880     const VkEvent*                              pEvents,
3881     VkPipelineStageFlags                        srcStageMask,
3882     VkPipelineStageFlags                        dstStageMask,
3883     uint32_t                                    memoryBarrierCount,
3884     const VkMemoryBarrier*                      pMemoryBarriers,
3885     uint32_t                                    bufferMemoryBarrierCount,
3886     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
3887     uint32_t                                    imageMemoryBarrierCount,
3888     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
3889 
3890 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
3891     VkCommandBuffer                             commandBuffer,
3892     VkPipelineStageFlags                        srcStageMask,
3893     VkPipelineStageFlags                        dstStageMask,
3894     VkDependencyFlags                           dependencyFlags,
3895     uint32_t                                    memoryBarrierCount,
3896     const VkMemoryBarrier*                      pMemoryBarriers,
3897     uint32_t                                    bufferMemoryBarrierCount,
3898     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
3899     uint32_t                                    imageMemoryBarrierCount,
3900     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
3901 
3902 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
3903     VkCommandBuffer                             commandBuffer,
3904     VkQueryPool                                 queryPool,
3905     uint32_t                                    query,
3906     VkQueryControlFlags                         flags);
3907 
3908 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
3909     VkCommandBuffer                             commandBuffer,
3910     VkQueryPool                                 queryPool,
3911     uint32_t                                    query);
3912 
3913 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
3914     VkCommandBuffer                             commandBuffer,
3915     VkQueryPool                                 queryPool,
3916     uint32_t                                    firstQuery,
3917     uint32_t                                    queryCount);
3918 
3919 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
3920     VkCommandBuffer                             commandBuffer,
3921     VkPipelineStageFlagBits                     pipelineStage,
3922     VkQueryPool                                 queryPool,
3923     uint32_t                                    query);
3924 
3925 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
3926     VkCommandBuffer                             commandBuffer,
3927     VkQueryPool                                 queryPool,
3928     uint32_t                                    firstQuery,
3929     uint32_t                                    queryCount,
3930     VkBuffer                                    dstBuffer,
3931     VkDeviceSize                                dstOffset,
3932     VkDeviceSize                                stride,
3933     VkQueryResultFlags                          flags);
3934 
3935 VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
3936     VkCommandBuffer                             commandBuffer,
3937     VkPipelineLayout                            layout,
3938     VkShaderStageFlags                          stageFlags,
3939     uint32_t                                    offset,
3940     uint32_t                                    size,
3941     const void*                                 pValues);
3942 
3943 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
3944     VkCommandBuffer                             commandBuffer,
3945     const VkRenderPassBeginInfo*                pRenderPassBegin,
3946     VkSubpassContents                           contents);
3947 
3948 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
3949     VkCommandBuffer                             commandBuffer,
3950     VkSubpassContents                           contents);
3951 
3952 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
3953     VkCommandBuffer                             commandBuffer);
3954 
3955 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
3956     VkCommandBuffer                             commandBuffer,
3957     uint32_t                                    commandBufferCount,
3958     const VkCommandBuffer*                      pCommandBuffers);
3959 #endif
3960 
3961 
3962 #define VK_VERSION_1_1 1
3963 // Vulkan 1.1 version number
3964 #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0
3965 
3966 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)
3967 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)
3968 #define VK_MAX_DEVICE_GROUP_SIZE          32
3969 #define VK_LUID_SIZE                      8
3970 #define VK_QUEUE_FAMILY_EXTERNAL          (~0U-1)
3971 
3972 typedef enum VkPointClippingBehavior {
3973     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
3974     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
3975     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
3976     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
3977     VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
3978     VK_POINT_CLIPPING_BEHAVIOR_END_RANGE = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
3979     VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES + 1),
3980     VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
3981 } VkPointClippingBehavior;
3982 
3983 typedef enum VkTessellationDomainOrigin {
3984     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
3985     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
3986     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
3987     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
3988     VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
3989     VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
3990     VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT + 1),
3991     VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
3992 } VkTessellationDomainOrigin;
3993 
3994 typedef enum VkSamplerYcbcrModelConversion {
3995     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
3996     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
3997     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,
3998     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,
3999     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
4000     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
4001     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
4002     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
4003     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
4004     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
4005     VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
4006     VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
4007     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY + 1),
4008     VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
4009 } VkSamplerYcbcrModelConversion;
4010 
4011 typedef enum VkSamplerYcbcrRange {
4012     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
4013     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
4014     VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
4015     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
4016     VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
4017     VK_SAMPLER_YCBCR_RANGE_END_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
4018     VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW - VK_SAMPLER_YCBCR_RANGE_ITU_FULL + 1),
4019     VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
4020 } VkSamplerYcbcrRange;
4021 
4022 typedef enum VkChromaLocation {
4023     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
4024     VK_CHROMA_LOCATION_MIDPOINT = 1,
4025     VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,
4026     VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,
4027     VK_CHROMA_LOCATION_BEGIN_RANGE = VK_CHROMA_LOCATION_COSITED_EVEN,
4028     VK_CHROMA_LOCATION_END_RANGE = VK_CHROMA_LOCATION_MIDPOINT,
4029     VK_CHROMA_LOCATION_RANGE_SIZE = (VK_CHROMA_LOCATION_MIDPOINT - VK_CHROMA_LOCATION_COSITED_EVEN + 1),
4030     VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
4031 } VkChromaLocation;
4032 
4033 typedef enum VkDescriptorUpdateTemplateType {
4034     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
4035     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
4036     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
4037     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
4038     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
4039     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET + 1),
4040     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
4041 } VkDescriptorUpdateTemplateType;
4042 
4043 typedef enum VkSubgroupFeatureFlagBits {
4044     VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,
4045     VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,
4046     VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,
4047     VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,
4048     VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,
4049     VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,
4050     VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
4051     VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
4052     VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
4053     VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4054 } VkSubgroupFeatureFlagBits;
4055 typedef VkFlags VkSubgroupFeatureFlags;
4056 
4057 typedef enum VkPeerMemoryFeatureFlagBits {
4058     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001,
4059     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002,
4060     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004,
4061     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,
4062     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
4063     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
4064     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
4065     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
4066     VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4067 } VkPeerMemoryFeatureFlagBits;
4068 typedef VkFlags VkPeerMemoryFeatureFlags;
4069 
4070 typedef enum VkMemoryAllocateFlagBits {
4071     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
4072     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = 0x00000002,
4073     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000004,
4074     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
4075     VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4076 } VkMemoryAllocateFlagBits;
4077 typedef VkFlags VkMemoryAllocateFlags;
4078 typedef VkFlags VkCommandPoolTrimFlags;
4079 typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;
4080 
4081 typedef enum VkExternalMemoryHandleTypeFlagBits {
4082     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4083     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4084     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4085     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,
4086     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,
4087     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,
4088     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,
4089     VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,
4090     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,
4091     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,
4092     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,
4093     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
4094     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4095     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4096     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
4097     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
4098     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
4099     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
4100     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4101 } VkExternalMemoryHandleTypeFlagBits;
4102 typedef VkFlags VkExternalMemoryHandleTypeFlags;
4103 
4104 typedef enum VkExternalMemoryFeatureFlagBits {
4105     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,
4106     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,
4107     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,
4108     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
4109     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
4110     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
4111     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4112 } VkExternalMemoryFeatureFlagBits;
4113 typedef VkFlags VkExternalMemoryFeatureFlags;
4114 
4115 typedef enum VkExternalFenceHandleTypeFlagBits {
4116     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4117     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4118     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4119     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,
4120     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
4121     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4122     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4123     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
4124     VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4125 } VkExternalFenceHandleTypeFlagBits;
4126 typedef VkFlags VkExternalFenceHandleTypeFlags;
4127 
4128 typedef enum VkExternalFenceFeatureFlagBits {
4129     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001,
4130     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,
4131     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
4132     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
4133     VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4134 } VkExternalFenceFeatureFlagBits;
4135 typedef VkFlags VkExternalFenceFeatureFlags;
4136 
4137 typedef enum VkFenceImportFlagBits {
4138     VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,
4139     VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,
4140     VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4141 } VkFenceImportFlagBits;
4142 typedef VkFlags VkFenceImportFlags;
4143 
4144 typedef enum VkSemaphoreImportFlagBits {
4145     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,
4146     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
4147     VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4148 } VkSemaphoreImportFlagBits;
4149 typedef VkFlags VkSemaphoreImportFlags;
4150 
4151 typedef enum VkExternalSemaphoreHandleTypeFlagBits {
4152     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
4153     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
4154     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
4155     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008,
4156     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,
4157     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
4158     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
4159     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
4160     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
4161     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
4162     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4163 } VkExternalSemaphoreHandleTypeFlagBits;
4164 typedef VkFlags VkExternalSemaphoreHandleTypeFlags;
4165 
4166 typedef enum VkExternalSemaphoreFeatureFlagBits {
4167     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001,
4168     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,
4169     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
4170     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
4171     VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
4172 } VkExternalSemaphoreFeatureFlagBits;
4173 typedef VkFlags VkExternalSemaphoreFeatureFlags;
4174 typedef struct VkPhysicalDeviceSubgroupProperties {
4175     VkStructureType           sType;
4176     void*                     pNext;
4177     uint32_t                  subgroupSize;
4178     VkShaderStageFlags        supportedStages;
4179     VkSubgroupFeatureFlags    supportedOperations;
4180     VkBool32                  quadOperationsInAllStages;
4181 } VkPhysicalDeviceSubgroupProperties;
4182 
4183 typedef struct VkBindBufferMemoryInfo {
4184     VkStructureType    sType;
4185     const void*        pNext;
4186     VkBuffer           buffer;
4187     VkDeviceMemory     memory;
4188     VkDeviceSize       memoryOffset;
4189 } VkBindBufferMemoryInfo;
4190 
4191 typedef struct VkBindImageMemoryInfo {
4192     VkStructureType    sType;
4193     const void*        pNext;
4194     VkImage            image;
4195     VkDeviceMemory     memory;
4196     VkDeviceSize       memoryOffset;
4197 } VkBindImageMemoryInfo;
4198 
4199 typedef struct VkPhysicalDevice16BitStorageFeatures {
4200     VkStructureType    sType;
4201     void*              pNext;
4202     VkBool32           storageBuffer16BitAccess;
4203     VkBool32           uniformAndStorageBuffer16BitAccess;
4204     VkBool32           storagePushConstant16;
4205     VkBool32           storageInputOutput16;
4206 } VkPhysicalDevice16BitStorageFeatures;
4207 
4208 typedef struct VkMemoryDedicatedRequirements {
4209     VkStructureType    sType;
4210     void*              pNext;
4211     VkBool32           prefersDedicatedAllocation;
4212     VkBool32           requiresDedicatedAllocation;
4213 } VkMemoryDedicatedRequirements;
4214 
4215 typedef struct VkMemoryDedicatedAllocateInfo {
4216     VkStructureType    sType;
4217     const void*        pNext;
4218     VkImage            image;
4219     VkBuffer           buffer;
4220 } VkMemoryDedicatedAllocateInfo;
4221 
4222 typedef struct VkMemoryAllocateFlagsInfo {
4223     VkStructureType          sType;
4224     const void*              pNext;
4225     VkMemoryAllocateFlags    flags;
4226     uint32_t                 deviceMask;
4227 } VkMemoryAllocateFlagsInfo;
4228 
4229 typedef struct VkDeviceGroupRenderPassBeginInfo {
4230     VkStructureType    sType;
4231     const void*        pNext;
4232     uint32_t           deviceMask;
4233     uint32_t           deviceRenderAreaCount;
4234     const VkRect2D*    pDeviceRenderAreas;
4235 } VkDeviceGroupRenderPassBeginInfo;
4236 
4237 typedef struct VkDeviceGroupCommandBufferBeginInfo {
4238     VkStructureType    sType;
4239     const void*        pNext;
4240     uint32_t           deviceMask;
4241 } VkDeviceGroupCommandBufferBeginInfo;
4242 
4243 typedef struct VkDeviceGroupSubmitInfo {
4244     VkStructureType    sType;
4245     const void*        pNext;
4246     uint32_t           waitSemaphoreCount;
4247     const uint32_t*    pWaitSemaphoreDeviceIndices;
4248     uint32_t           commandBufferCount;
4249     const uint32_t*    pCommandBufferDeviceMasks;
4250     uint32_t           signalSemaphoreCount;
4251     const uint32_t*    pSignalSemaphoreDeviceIndices;
4252 } VkDeviceGroupSubmitInfo;
4253 
4254 typedef struct VkDeviceGroupBindSparseInfo {
4255     VkStructureType    sType;
4256     const void*        pNext;
4257     uint32_t           resourceDeviceIndex;
4258     uint32_t           memoryDeviceIndex;
4259 } VkDeviceGroupBindSparseInfo;
4260 
4261 typedef struct VkBindBufferMemoryDeviceGroupInfo {
4262     VkStructureType    sType;
4263     const void*        pNext;
4264     uint32_t           deviceIndexCount;
4265     const uint32_t*    pDeviceIndices;
4266 } VkBindBufferMemoryDeviceGroupInfo;
4267 
4268 typedef struct VkBindImageMemoryDeviceGroupInfo {
4269     VkStructureType    sType;
4270     const void*        pNext;
4271     uint32_t           deviceIndexCount;
4272     const uint32_t*    pDeviceIndices;
4273     uint32_t           splitInstanceBindRegionCount;
4274     const VkRect2D*    pSplitInstanceBindRegions;
4275 } VkBindImageMemoryDeviceGroupInfo;
4276 
4277 typedef struct VkPhysicalDeviceGroupProperties {
4278     VkStructureType     sType;
4279     void*               pNext;
4280     uint32_t            physicalDeviceCount;
4281     VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
4282     VkBool32            subsetAllocation;
4283 } VkPhysicalDeviceGroupProperties;
4284 
4285 typedef struct VkDeviceGroupDeviceCreateInfo {
4286     VkStructureType            sType;
4287     const void*                pNext;
4288     uint32_t                   physicalDeviceCount;
4289     const VkPhysicalDevice*    pPhysicalDevices;
4290 } VkDeviceGroupDeviceCreateInfo;
4291 
4292 typedef struct VkBufferMemoryRequirementsInfo2 {
4293     VkStructureType    sType;
4294     const void*        pNext;
4295     VkBuffer           buffer;
4296 } VkBufferMemoryRequirementsInfo2;
4297 
4298 typedef struct VkImageMemoryRequirementsInfo2 {
4299     VkStructureType    sType;
4300     const void*        pNext;
4301     VkImage            image;
4302 } VkImageMemoryRequirementsInfo2;
4303 
4304 typedef struct VkImageSparseMemoryRequirementsInfo2 {
4305     VkStructureType    sType;
4306     const void*        pNext;
4307     VkImage            image;
4308 } VkImageSparseMemoryRequirementsInfo2;
4309 
4310 typedef struct VkMemoryRequirements2 {
4311     VkStructureType         sType;
4312     void*                   pNext;
4313     VkMemoryRequirements    memoryRequirements;
4314 } VkMemoryRequirements2;
4315 
4316 typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
4317 
4318 typedef struct VkSparseImageMemoryRequirements2 {
4319     VkStructureType                    sType;
4320     void*                              pNext;
4321     VkSparseImageMemoryRequirements    memoryRequirements;
4322 } VkSparseImageMemoryRequirements2;
4323 
4324 typedef struct VkPhysicalDeviceFeatures2 {
4325     VkStructureType             sType;
4326     void*                       pNext;
4327     VkPhysicalDeviceFeatures    features;
4328 } VkPhysicalDeviceFeatures2;
4329 
4330 typedef struct VkPhysicalDeviceProperties2 {
4331     VkStructureType               sType;
4332     void*                         pNext;
4333     VkPhysicalDeviceProperties    properties;
4334 } VkPhysicalDeviceProperties2;
4335 
4336 typedef struct VkFormatProperties2 {
4337     VkStructureType       sType;
4338     void*                 pNext;
4339     VkFormatProperties    formatProperties;
4340 } VkFormatProperties2;
4341 
4342 typedef struct VkImageFormatProperties2 {
4343     VkStructureType            sType;
4344     void*                      pNext;
4345     VkImageFormatProperties    imageFormatProperties;
4346 } VkImageFormatProperties2;
4347 
4348 typedef struct VkPhysicalDeviceImageFormatInfo2 {
4349     VkStructureType       sType;
4350     const void*           pNext;
4351     VkFormat              format;
4352     VkImageType           type;
4353     VkImageTiling         tiling;
4354     VkImageUsageFlags     usage;
4355     VkImageCreateFlags    flags;
4356 } VkPhysicalDeviceImageFormatInfo2;
4357 
4358 typedef struct VkQueueFamilyProperties2 {
4359     VkStructureType            sType;
4360     void*                      pNext;
4361     VkQueueFamilyProperties    queueFamilyProperties;
4362 } VkQueueFamilyProperties2;
4363 
4364 typedef struct VkPhysicalDeviceMemoryProperties2 {
4365     VkStructureType                     sType;
4366     void*                               pNext;
4367     VkPhysicalDeviceMemoryProperties    memoryProperties;
4368 } VkPhysicalDeviceMemoryProperties2;
4369 
4370 typedef struct VkSparseImageFormatProperties2 {
4371     VkStructureType                  sType;
4372     void*                            pNext;
4373     VkSparseImageFormatProperties    properties;
4374 } VkSparseImageFormatProperties2;
4375 
4376 typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {
4377     VkStructureType          sType;
4378     const void*              pNext;
4379     VkFormat                 format;
4380     VkImageType              type;
4381     VkSampleCountFlagBits    samples;
4382     VkImageUsageFlags        usage;
4383     VkImageTiling            tiling;
4384 } VkPhysicalDeviceSparseImageFormatInfo2;
4385 
4386 typedef struct VkPhysicalDevicePointClippingProperties {
4387     VkStructureType            sType;
4388     void*                      pNext;
4389     VkPointClippingBehavior    pointClippingBehavior;
4390 } VkPhysicalDevicePointClippingProperties;
4391 
4392 typedef struct VkInputAttachmentAspectReference {
4393     uint32_t              subpass;
4394     uint32_t              inputAttachmentIndex;
4395     VkImageAspectFlags    aspectMask;
4396 } VkInputAttachmentAspectReference;
4397 
4398 typedef struct VkRenderPassInputAttachmentAspectCreateInfo {
4399     VkStructureType                            sType;
4400     const void*                                pNext;
4401     uint32_t                                   aspectReferenceCount;
4402     const VkInputAttachmentAspectReference*    pAspectReferences;
4403 } VkRenderPassInputAttachmentAspectCreateInfo;
4404 
4405 typedef struct VkImageViewUsageCreateInfo {
4406     VkStructureType      sType;
4407     const void*          pNext;
4408     VkImageUsageFlags    usage;
4409 } VkImageViewUsageCreateInfo;
4410 
4411 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo {
4412     VkStructureType               sType;
4413     const void*                   pNext;
4414     VkTessellationDomainOrigin    domainOrigin;
4415 } VkPipelineTessellationDomainOriginStateCreateInfo;
4416 
4417 typedef struct VkRenderPassMultiviewCreateInfo {
4418     VkStructureType    sType;
4419     const void*        pNext;
4420     uint32_t           subpassCount;
4421     const uint32_t*    pViewMasks;
4422     uint32_t           dependencyCount;
4423     const int32_t*     pViewOffsets;
4424     uint32_t           correlationMaskCount;
4425     const uint32_t*    pCorrelationMasks;
4426 } VkRenderPassMultiviewCreateInfo;
4427 
4428 typedef struct VkPhysicalDeviceMultiviewFeatures {
4429     VkStructureType    sType;
4430     void*              pNext;
4431     VkBool32           multiview;
4432     VkBool32           multiviewGeometryShader;
4433     VkBool32           multiviewTessellationShader;
4434 } VkPhysicalDeviceMultiviewFeatures;
4435 
4436 typedef struct VkPhysicalDeviceMultiviewProperties {
4437     VkStructureType    sType;
4438     void*              pNext;
4439     uint32_t           maxMultiviewViewCount;
4440     uint32_t           maxMultiviewInstanceIndex;
4441 } VkPhysicalDeviceMultiviewProperties;
4442 
4443 typedef struct VkPhysicalDeviceVariablePointersFeatures {
4444     VkStructureType    sType;
4445     void*              pNext;
4446     VkBool32           variablePointersStorageBuffer;
4447     VkBool32           variablePointers;
4448 } VkPhysicalDeviceVariablePointersFeatures;
4449 
4450 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;
4451 
4452 typedef struct VkPhysicalDeviceProtectedMemoryFeatures {
4453     VkStructureType    sType;
4454     void*              pNext;
4455     VkBool32           protectedMemory;
4456 } VkPhysicalDeviceProtectedMemoryFeatures;
4457 
4458 typedef struct VkPhysicalDeviceProtectedMemoryProperties {
4459     VkStructureType    sType;
4460     void*              pNext;
4461     VkBool32           protectedNoFault;
4462 } VkPhysicalDeviceProtectedMemoryProperties;
4463 
4464 typedef struct VkDeviceQueueInfo2 {
4465     VkStructureType             sType;
4466     const void*                 pNext;
4467     VkDeviceQueueCreateFlags    flags;
4468     uint32_t                    queueFamilyIndex;
4469     uint32_t                    queueIndex;
4470 } VkDeviceQueueInfo2;
4471 
4472 typedef struct VkProtectedSubmitInfo {
4473     VkStructureType    sType;
4474     const void*        pNext;
4475     VkBool32           protectedSubmit;
4476 } VkProtectedSubmitInfo;
4477 
4478 typedef struct VkSamplerYcbcrConversionCreateInfo {
4479     VkStructureType                  sType;
4480     const void*                      pNext;
4481     VkFormat                         format;
4482     VkSamplerYcbcrModelConversion    ycbcrModel;
4483     VkSamplerYcbcrRange              ycbcrRange;
4484     VkComponentMapping               components;
4485     VkChromaLocation                 xChromaOffset;
4486     VkChromaLocation                 yChromaOffset;
4487     VkFilter                         chromaFilter;
4488     VkBool32                         forceExplicitReconstruction;
4489 } VkSamplerYcbcrConversionCreateInfo;
4490 
4491 typedef struct VkSamplerYcbcrConversionInfo {
4492     VkStructureType             sType;
4493     const void*                 pNext;
4494     VkSamplerYcbcrConversion    conversion;
4495 } VkSamplerYcbcrConversionInfo;
4496 
4497 typedef struct VkBindImagePlaneMemoryInfo {
4498     VkStructureType          sType;
4499     const void*              pNext;
4500     VkImageAspectFlagBits    planeAspect;
4501 } VkBindImagePlaneMemoryInfo;
4502 
4503 typedef struct VkImagePlaneMemoryRequirementsInfo {
4504     VkStructureType          sType;
4505     const void*              pNext;
4506     VkImageAspectFlagBits    planeAspect;
4507 } VkImagePlaneMemoryRequirementsInfo;
4508 
4509 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
4510     VkStructureType    sType;
4511     void*              pNext;
4512     VkBool32           samplerYcbcrConversion;
4513 } VkPhysicalDeviceSamplerYcbcrConversionFeatures;
4514 
4515 typedef struct VkSamplerYcbcrConversionImageFormatProperties {
4516     VkStructureType    sType;
4517     void*              pNext;
4518     uint32_t           combinedImageSamplerDescriptorCount;
4519 } VkSamplerYcbcrConversionImageFormatProperties;
4520 
4521 typedef struct VkDescriptorUpdateTemplateEntry {
4522     uint32_t            dstBinding;
4523     uint32_t            dstArrayElement;
4524     uint32_t            descriptorCount;
4525     VkDescriptorType    descriptorType;
4526     size_t              offset;
4527     size_t              stride;
4528 } VkDescriptorUpdateTemplateEntry;
4529 
4530 typedef struct VkDescriptorUpdateTemplateCreateInfo {
4531     VkStructureType                           sType;
4532     const void*                               pNext;
4533     VkDescriptorUpdateTemplateCreateFlags     flags;
4534     uint32_t                                  descriptorUpdateEntryCount;
4535     const VkDescriptorUpdateTemplateEntry*    pDescriptorUpdateEntries;
4536     VkDescriptorUpdateTemplateType            templateType;
4537     VkDescriptorSetLayout                     descriptorSetLayout;
4538     VkPipelineBindPoint                       pipelineBindPoint;
4539     VkPipelineLayout                          pipelineLayout;
4540     uint32_t                                  set;
4541 } VkDescriptorUpdateTemplateCreateInfo;
4542 
4543 typedef struct VkExternalMemoryProperties {
4544     VkExternalMemoryFeatureFlags       externalMemoryFeatures;
4545     VkExternalMemoryHandleTypeFlags    exportFromImportedHandleTypes;
4546     VkExternalMemoryHandleTypeFlags    compatibleHandleTypes;
4547 } VkExternalMemoryProperties;
4548 
4549 typedef struct VkPhysicalDeviceExternalImageFormatInfo {
4550     VkStructureType                       sType;
4551     const void*                           pNext;
4552     VkExternalMemoryHandleTypeFlagBits    handleType;
4553 } VkPhysicalDeviceExternalImageFormatInfo;
4554 
4555 typedef struct VkExternalImageFormatProperties {
4556     VkStructureType               sType;
4557     void*                         pNext;
4558     VkExternalMemoryProperties    externalMemoryProperties;
4559 } VkExternalImageFormatProperties;
4560 
4561 typedef struct VkPhysicalDeviceExternalBufferInfo {
4562     VkStructureType                       sType;
4563     const void*                           pNext;
4564     VkBufferCreateFlags                   flags;
4565     VkBufferUsageFlags                    usage;
4566     VkExternalMemoryHandleTypeFlagBits    handleType;
4567 } VkPhysicalDeviceExternalBufferInfo;
4568 
4569 typedef struct VkExternalBufferProperties {
4570     VkStructureType               sType;
4571     void*                         pNext;
4572     VkExternalMemoryProperties    externalMemoryProperties;
4573 } VkExternalBufferProperties;
4574 
4575 typedef struct VkPhysicalDeviceIDProperties {
4576     VkStructureType    sType;
4577     void*              pNext;
4578     uint8_t            deviceUUID[VK_UUID_SIZE];
4579     uint8_t            driverUUID[VK_UUID_SIZE];
4580     uint8_t            deviceLUID[VK_LUID_SIZE];
4581     uint32_t           deviceNodeMask;
4582     VkBool32           deviceLUIDValid;
4583 } VkPhysicalDeviceIDProperties;
4584 
4585 typedef struct VkExternalMemoryImageCreateInfo {
4586     VkStructureType                    sType;
4587     const void*                        pNext;
4588     VkExternalMemoryHandleTypeFlags    handleTypes;
4589 } VkExternalMemoryImageCreateInfo;
4590 
4591 typedef struct VkExternalMemoryBufferCreateInfo {
4592     VkStructureType                    sType;
4593     const void*                        pNext;
4594     VkExternalMemoryHandleTypeFlags    handleTypes;
4595 } VkExternalMemoryBufferCreateInfo;
4596 
4597 typedef struct VkExportMemoryAllocateInfo {
4598     VkStructureType                    sType;
4599     const void*                        pNext;
4600     VkExternalMemoryHandleTypeFlags    handleTypes;
4601 } VkExportMemoryAllocateInfo;
4602 
4603 typedef struct VkPhysicalDeviceExternalFenceInfo {
4604     VkStructureType                      sType;
4605     const void*                          pNext;
4606     VkExternalFenceHandleTypeFlagBits    handleType;
4607 } VkPhysicalDeviceExternalFenceInfo;
4608 
4609 typedef struct VkExternalFenceProperties {
4610     VkStructureType                   sType;
4611     void*                             pNext;
4612     VkExternalFenceHandleTypeFlags    exportFromImportedHandleTypes;
4613     VkExternalFenceHandleTypeFlags    compatibleHandleTypes;
4614     VkExternalFenceFeatureFlags       externalFenceFeatures;
4615 } VkExternalFenceProperties;
4616 
4617 typedef struct VkExportFenceCreateInfo {
4618     VkStructureType                   sType;
4619     const void*                       pNext;
4620     VkExternalFenceHandleTypeFlags    handleTypes;
4621 } VkExportFenceCreateInfo;
4622 
4623 typedef struct VkExportSemaphoreCreateInfo {
4624     VkStructureType                       sType;
4625     const void*                           pNext;
4626     VkExternalSemaphoreHandleTypeFlags    handleTypes;
4627 } VkExportSemaphoreCreateInfo;
4628 
4629 typedef struct VkPhysicalDeviceExternalSemaphoreInfo {
4630     VkStructureType                          sType;
4631     const void*                              pNext;
4632     VkExternalSemaphoreHandleTypeFlagBits    handleType;
4633 } VkPhysicalDeviceExternalSemaphoreInfo;
4634 
4635 typedef struct VkExternalSemaphoreProperties {
4636     VkStructureType                       sType;
4637     void*                                 pNext;
4638     VkExternalSemaphoreHandleTypeFlags    exportFromImportedHandleTypes;
4639     VkExternalSemaphoreHandleTypeFlags    compatibleHandleTypes;
4640     VkExternalSemaphoreFeatureFlags       externalSemaphoreFeatures;
4641 } VkExternalSemaphoreProperties;
4642 
4643 typedef struct VkPhysicalDeviceMaintenance3Properties {
4644     VkStructureType    sType;
4645     void*              pNext;
4646     uint32_t           maxPerSetDescriptors;
4647     VkDeviceSize       maxMemoryAllocationSize;
4648 } VkPhysicalDeviceMaintenance3Properties;
4649 
4650 typedef struct VkDescriptorSetLayoutSupport {
4651     VkStructureType    sType;
4652     void*              pNext;
4653     VkBool32           supported;
4654 } VkDescriptorSetLayoutSupport;
4655 
4656 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures {
4657     VkStructureType    sType;
4658     void*              pNext;
4659     VkBool32           shaderDrawParameters;
4660 } VkPhysicalDeviceShaderDrawParametersFeatures;
4661 
4662 typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;
4663 
4664 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion);
4665 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
4666 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
4667 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
4668 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
4669 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);
4670 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
4671 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
4672 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
4673 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
4674 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
4675 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
4676 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
4677 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
4678 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
4679 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
4680 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
4681 typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
4682 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
4683 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
4684 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
4685 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
4686 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
4687 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
4688 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
4689 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
4690 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
4691 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
4692 
4693 #ifndef VK_NO_PROTOTYPES
4694 VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(
4695     uint32_t*                                   pApiVersion);
4696 
4697 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(
4698     VkDevice                                    device,
4699     uint32_t                                    bindInfoCount,
4700     const VkBindBufferMemoryInfo*               pBindInfos);
4701 
4702 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(
4703     VkDevice                                    device,
4704     uint32_t                                    bindInfoCount,
4705     const VkBindImageMemoryInfo*                pBindInfos);
4706 
4707 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(
4708     VkDevice                                    device,
4709     uint32_t                                    heapIndex,
4710     uint32_t                                    localDeviceIndex,
4711     uint32_t                                    remoteDeviceIndex,
4712     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
4713 
4714 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(
4715     VkCommandBuffer                             commandBuffer,
4716     uint32_t                                    deviceMask);
4717 
4718 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(
4719     VkCommandBuffer                             commandBuffer,
4720     uint32_t                                    baseGroupX,
4721     uint32_t                                    baseGroupY,
4722     uint32_t                                    baseGroupZ,
4723     uint32_t                                    groupCountX,
4724     uint32_t                                    groupCountY,
4725     uint32_t                                    groupCountZ);
4726 
4727 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(
4728     VkInstance                                  instance,
4729     uint32_t*                                   pPhysicalDeviceGroupCount,
4730     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
4731 
4732 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(
4733     VkDevice                                    device,
4734     const VkImageMemoryRequirementsInfo2*       pInfo,
4735     VkMemoryRequirements2*                      pMemoryRequirements);
4736 
4737 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(
4738     VkDevice                                    device,
4739     const VkBufferMemoryRequirementsInfo2*      pInfo,
4740     VkMemoryRequirements2*                      pMemoryRequirements);
4741 
4742 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(
4743     VkDevice                                    device,
4744     const VkImageSparseMemoryRequirementsInfo2* pInfo,
4745     uint32_t*                                   pSparseMemoryRequirementCount,
4746     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
4747 
4748 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(
4749     VkPhysicalDevice                            physicalDevice,
4750     VkPhysicalDeviceFeatures2*                  pFeatures);
4751 
4752 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(
4753     VkPhysicalDevice                            physicalDevice,
4754     VkPhysicalDeviceProperties2*                pProperties);
4755 
4756 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(
4757     VkPhysicalDevice                            physicalDevice,
4758     VkFormat                                    format,
4759     VkFormatProperties2*                        pFormatProperties);
4760 
4761 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(
4762     VkPhysicalDevice                            physicalDevice,
4763     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
4764     VkImageFormatProperties2*                   pImageFormatProperties);
4765 
4766 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(
4767     VkPhysicalDevice                            physicalDevice,
4768     uint32_t*                                   pQueueFamilyPropertyCount,
4769     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
4770 
4771 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(
4772     VkPhysicalDevice                            physicalDevice,
4773     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
4774 
4775 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(
4776     VkPhysicalDevice                            physicalDevice,
4777     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
4778     uint32_t*                                   pPropertyCount,
4779     VkSparseImageFormatProperties2*             pProperties);
4780 
4781 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(
4782     VkDevice                                    device,
4783     VkCommandPool                               commandPool,
4784     VkCommandPoolTrimFlags                      flags);
4785 
4786 VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(
4787     VkDevice                                    device,
4788     const VkDeviceQueueInfo2*                   pQueueInfo,
4789     VkQueue*                                    pQueue);
4790 
4791 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(
4792     VkDevice                                    device,
4793     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
4794     const VkAllocationCallbacks*                pAllocator,
4795     VkSamplerYcbcrConversion*                   pYcbcrConversion);
4796 
4797 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(
4798     VkDevice                                    device,
4799     VkSamplerYcbcrConversion                    ycbcrConversion,
4800     const VkAllocationCallbacks*                pAllocator);
4801 
4802 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(
4803     VkDevice                                    device,
4804     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
4805     const VkAllocationCallbacks*                pAllocator,
4806     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
4807 
4808 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(
4809     VkDevice                                    device,
4810     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
4811     const VkAllocationCallbacks*                pAllocator);
4812 
4813 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(
4814     VkDevice                                    device,
4815     VkDescriptorSet                             descriptorSet,
4816     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
4817     const void*                                 pData);
4818 
4819 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(
4820     VkPhysicalDevice                            physicalDevice,
4821     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
4822     VkExternalBufferProperties*                 pExternalBufferProperties);
4823 
4824 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(
4825     VkPhysicalDevice                            physicalDevice,
4826     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
4827     VkExternalFenceProperties*                  pExternalFenceProperties);
4828 
4829 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(
4830     VkPhysicalDevice                            physicalDevice,
4831     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
4832     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
4833 
4834 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(
4835     VkDevice                                    device,
4836     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
4837     VkDescriptorSetLayoutSupport*               pSupport);
4838 #endif
4839 
4840 
4841 #define VK_KHR_surface 1
4842 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
4843 #define VK_KHR_SURFACE_SPEC_VERSION       25
4844 #define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
4845 
4846 typedef enum VkColorSpaceKHR {
4847     VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
4848     VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
4849     VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
4850     VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003,
4851     VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
4852     VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
4853     VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
4854     VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
4855     VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
4856     VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
4857     VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
4858     VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
4859     VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
4860     VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
4861     VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
4862     VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000,
4863     VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
4864     VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
4865     VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
4866     VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
4867     VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
4868     VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
4869 } VkColorSpaceKHR;
4870 
4871 typedef enum VkPresentModeKHR {
4872     VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
4873     VK_PRESENT_MODE_MAILBOX_KHR = 1,
4874     VK_PRESENT_MODE_FIFO_KHR = 2,
4875     VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
4876     VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
4877     VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
4878     VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
4879     VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
4880     VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
4881     VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
4882 } VkPresentModeKHR;
4883 
4884 typedef enum VkSurfaceTransformFlagBitsKHR {
4885     VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
4886     VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
4887     VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
4888     VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
4889     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
4890     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
4891     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
4892     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
4893     VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
4894     VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4895 } VkSurfaceTransformFlagBitsKHR;
4896 typedef VkFlags VkSurfaceTransformFlagsKHR;
4897 
4898 typedef enum VkCompositeAlphaFlagBitsKHR {
4899     VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
4900     VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
4901     VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
4902     VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
4903     VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4904 } VkCompositeAlphaFlagBitsKHR;
4905 typedef VkFlags VkCompositeAlphaFlagsKHR;
4906 typedef struct VkSurfaceCapabilitiesKHR {
4907     uint32_t                         minImageCount;
4908     uint32_t                         maxImageCount;
4909     VkExtent2D                       currentExtent;
4910     VkExtent2D                       minImageExtent;
4911     VkExtent2D                       maxImageExtent;
4912     uint32_t                         maxImageArrayLayers;
4913     VkSurfaceTransformFlagsKHR       supportedTransforms;
4914     VkSurfaceTransformFlagBitsKHR    currentTransform;
4915     VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
4916     VkImageUsageFlags                supportedUsageFlags;
4917 } VkSurfaceCapabilitiesKHR;
4918 
4919 typedef struct VkSurfaceFormatKHR {
4920     VkFormat           format;
4921     VkColorSpaceKHR    colorSpace;
4922 } VkSurfaceFormatKHR;
4923 
4924 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
4925 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
4926 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
4927 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
4928 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
4929 
4930 #ifndef VK_NO_PROTOTYPES
4931 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
4932     VkInstance                                  instance,
4933     VkSurfaceKHR                                surface,
4934     const VkAllocationCallbacks*                pAllocator);
4935 
4936 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
4937     VkPhysicalDevice                            physicalDevice,
4938     uint32_t                                    queueFamilyIndex,
4939     VkSurfaceKHR                                surface,
4940     VkBool32*                                   pSupported);
4941 
4942 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
4943     VkPhysicalDevice                            physicalDevice,
4944     VkSurfaceKHR                                surface,
4945     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
4946 
4947 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
4948     VkPhysicalDevice                            physicalDevice,
4949     VkSurfaceKHR                                surface,
4950     uint32_t*                                   pSurfaceFormatCount,
4951     VkSurfaceFormatKHR*                         pSurfaceFormats);
4952 
4953 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
4954     VkPhysicalDevice                            physicalDevice,
4955     VkSurfaceKHR                                surface,
4956     uint32_t*                                   pPresentModeCount,
4957     VkPresentModeKHR*                           pPresentModes);
4958 #endif
4959 
4960 
4961 #define VK_KHR_swapchain 1
4962 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
4963 #define VK_KHR_SWAPCHAIN_SPEC_VERSION     70
4964 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
4965 
4966 typedef enum VkSwapchainCreateFlagBitsKHR {
4967     VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,
4968     VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002,
4969     VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004,
4970     VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4971 } VkSwapchainCreateFlagBitsKHR;
4972 typedef VkFlags VkSwapchainCreateFlagsKHR;
4973 
4974 typedef enum VkDeviceGroupPresentModeFlagBitsKHR {
4975     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001,
4976     VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002,
4977     VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004,
4978     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,
4979     VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
4980 } VkDeviceGroupPresentModeFlagBitsKHR;
4981 typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;
4982 typedef struct VkSwapchainCreateInfoKHR {
4983     VkStructureType                  sType;
4984     const void*                      pNext;
4985     VkSwapchainCreateFlagsKHR        flags;
4986     VkSurfaceKHR                     surface;
4987     uint32_t                         minImageCount;
4988     VkFormat                         imageFormat;
4989     VkColorSpaceKHR                  imageColorSpace;
4990     VkExtent2D                       imageExtent;
4991     uint32_t                         imageArrayLayers;
4992     VkImageUsageFlags                imageUsage;
4993     VkSharingMode                    imageSharingMode;
4994     uint32_t                         queueFamilyIndexCount;
4995     const uint32_t*                  pQueueFamilyIndices;
4996     VkSurfaceTransformFlagBitsKHR    preTransform;
4997     VkCompositeAlphaFlagBitsKHR      compositeAlpha;
4998     VkPresentModeKHR                 presentMode;
4999     VkBool32                         clipped;
5000     VkSwapchainKHR                   oldSwapchain;
5001 } VkSwapchainCreateInfoKHR;
5002 
5003 typedef struct VkPresentInfoKHR {
5004     VkStructureType          sType;
5005     const void*              pNext;
5006     uint32_t                 waitSemaphoreCount;
5007     const VkSemaphore*       pWaitSemaphores;
5008     uint32_t                 swapchainCount;
5009     const VkSwapchainKHR*    pSwapchains;
5010     const uint32_t*          pImageIndices;
5011     VkResult*                pResults;
5012 } VkPresentInfoKHR;
5013 
5014 typedef struct VkImageSwapchainCreateInfoKHR {
5015     VkStructureType    sType;
5016     const void*        pNext;
5017     VkSwapchainKHR     swapchain;
5018 } VkImageSwapchainCreateInfoKHR;
5019 
5020 typedef struct VkBindImageMemorySwapchainInfoKHR {
5021     VkStructureType    sType;
5022     const void*        pNext;
5023     VkSwapchainKHR     swapchain;
5024     uint32_t           imageIndex;
5025 } VkBindImageMemorySwapchainInfoKHR;
5026 
5027 typedef struct VkAcquireNextImageInfoKHR {
5028     VkStructureType    sType;
5029     const void*        pNext;
5030     VkSwapchainKHR     swapchain;
5031     uint64_t           timeout;
5032     VkSemaphore        semaphore;
5033     VkFence            fence;
5034     uint32_t           deviceMask;
5035 } VkAcquireNextImageInfoKHR;
5036 
5037 typedef struct VkDeviceGroupPresentCapabilitiesKHR {
5038     VkStructureType                     sType;
5039     const void*                         pNext;
5040     uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE];
5041     VkDeviceGroupPresentModeFlagsKHR    modes;
5042 } VkDeviceGroupPresentCapabilitiesKHR;
5043 
5044 typedef struct VkDeviceGroupPresentInfoKHR {
5045     VkStructureType                        sType;
5046     const void*                            pNext;
5047     uint32_t                               swapchainCount;
5048     const uint32_t*                        pDeviceMasks;
5049     VkDeviceGroupPresentModeFlagBitsKHR    mode;
5050 } VkDeviceGroupPresentInfoKHR;
5051 
5052 typedef struct VkDeviceGroupSwapchainCreateInfoKHR {
5053     VkStructureType                     sType;
5054     const void*                         pNext;
5055     VkDeviceGroupPresentModeFlagsKHR    modes;
5056 } VkDeviceGroupSwapchainCreateInfoKHR;
5057 
5058 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
5059 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
5060 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
5061 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
5062 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
5063 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
5064 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
5065 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
5066 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
5067 
5068 #ifndef VK_NO_PROTOTYPES
5069 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
5070     VkDevice                                    device,
5071     const VkSwapchainCreateInfoKHR*             pCreateInfo,
5072     const VkAllocationCallbacks*                pAllocator,
5073     VkSwapchainKHR*                             pSwapchain);
5074 
5075 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
5076     VkDevice                                    device,
5077     VkSwapchainKHR                              swapchain,
5078     const VkAllocationCallbacks*                pAllocator);
5079 
5080 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
5081     VkDevice                                    device,
5082     VkSwapchainKHR                              swapchain,
5083     uint32_t*                                   pSwapchainImageCount,
5084     VkImage*                                    pSwapchainImages);
5085 
5086 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
5087     VkDevice                                    device,
5088     VkSwapchainKHR                              swapchain,
5089     uint64_t                                    timeout,
5090     VkSemaphore                                 semaphore,
5091     VkFence                                     fence,
5092     uint32_t*                                   pImageIndex);
5093 
5094 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
5095     VkQueue                                     queue,
5096     const VkPresentInfoKHR*                     pPresentInfo);
5097 
5098 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(
5099     VkDevice                                    device,
5100     VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
5101 
5102 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(
5103     VkDevice                                    device,
5104     VkSurfaceKHR                                surface,
5105     VkDeviceGroupPresentModeFlagsKHR*           pModes);
5106 
5107 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(
5108     VkPhysicalDevice                            physicalDevice,
5109     VkSurfaceKHR                                surface,
5110     uint32_t*                                   pRectCount,
5111     VkRect2D*                                   pRects);
5112 
5113 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(
5114     VkDevice                                    device,
5115     const VkAcquireNextImageInfoKHR*            pAcquireInfo,
5116     uint32_t*                                   pImageIndex);
5117 #endif
5118 
5119 
5120 #define VK_KHR_display 1
5121 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
5122 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
5123 #define VK_KHR_DISPLAY_SPEC_VERSION       23
5124 #define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
5125 
5126 typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
5127     VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
5128     VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
5129     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
5130     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
5131     VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
5132 } VkDisplayPlaneAlphaFlagBitsKHR;
5133 typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
5134 typedef VkFlags VkDisplayModeCreateFlagsKHR;
5135 typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
5136 typedef struct VkDisplayPropertiesKHR {
5137     VkDisplayKHR                  display;
5138     const char*                   displayName;
5139     VkExtent2D                    physicalDimensions;
5140     VkExtent2D                    physicalResolution;
5141     VkSurfaceTransformFlagsKHR    supportedTransforms;
5142     VkBool32                      planeReorderPossible;
5143     VkBool32                      persistentContent;
5144 } VkDisplayPropertiesKHR;
5145 
5146 typedef struct VkDisplayModeParametersKHR {
5147     VkExtent2D    visibleRegion;
5148     uint32_t      refreshRate;
5149 } VkDisplayModeParametersKHR;
5150 
5151 typedef struct VkDisplayModePropertiesKHR {
5152     VkDisplayModeKHR              displayMode;
5153     VkDisplayModeParametersKHR    parameters;
5154 } VkDisplayModePropertiesKHR;
5155 
5156 typedef struct VkDisplayModeCreateInfoKHR {
5157     VkStructureType                sType;
5158     const void*                    pNext;
5159     VkDisplayModeCreateFlagsKHR    flags;
5160     VkDisplayModeParametersKHR     parameters;
5161 } VkDisplayModeCreateInfoKHR;
5162 
5163 typedef struct VkDisplayPlaneCapabilitiesKHR {
5164     VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
5165     VkOffset2D                     minSrcPosition;
5166     VkOffset2D                     maxSrcPosition;
5167     VkExtent2D                     minSrcExtent;
5168     VkExtent2D                     maxSrcExtent;
5169     VkOffset2D                     minDstPosition;
5170     VkOffset2D                     maxDstPosition;
5171     VkExtent2D                     minDstExtent;
5172     VkExtent2D                     maxDstExtent;
5173 } VkDisplayPlaneCapabilitiesKHR;
5174 
5175 typedef struct VkDisplayPlanePropertiesKHR {
5176     VkDisplayKHR    currentDisplay;
5177     uint32_t        currentStackIndex;
5178 } VkDisplayPlanePropertiesKHR;
5179 
5180 typedef struct VkDisplaySurfaceCreateInfoKHR {
5181     VkStructureType                   sType;
5182     const void*                       pNext;
5183     VkDisplaySurfaceCreateFlagsKHR    flags;
5184     VkDisplayModeKHR                  displayMode;
5185     uint32_t                          planeIndex;
5186     uint32_t                          planeStackIndex;
5187     VkSurfaceTransformFlagBitsKHR     transform;
5188     float                             globalAlpha;
5189     VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
5190     VkExtent2D                        imageExtent;
5191 } VkDisplaySurfaceCreateInfoKHR;
5192 
5193 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
5194 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
5195 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
5196 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
5197 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
5198 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
5199 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
5200 
5201 #ifndef VK_NO_PROTOTYPES
5202 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
5203     VkPhysicalDevice                            physicalDevice,
5204     uint32_t*                                   pPropertyCount,
5205     VkDisplayPropertiesKHR*                     pProperties);
5206 
5207 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
5208     VkPhysicalDevice                            physicalDevice,
5209     uint32_t*                                   pPropertyCount,
5210     VkDisplayPlanePropertiesKHR*                pProperties);
5211 
5212 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
5213     VkPhysicalDevice                            physicalDevice,
5214     uint32_t                                    planeIndex,
5215     uint32_t*                                   pDisplayCount,
5216     VkDisplayKHR*                               pDisplays);
5217 
5218 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
5219     VkPhysicalDevice                            physicalDevice,
5220     VkDisplayKHR                                display,
5221     uint32_t*                                   pPropertyCount,
5222     VkDisplayModePropertiesKHR*                 pProperties);
5223 
5224 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
5225     VkPhysicalDevice                            physicalDevice,
5226     VkDisplayKHR                                display,
5227     const VkDisplayModeCreateInfoKHR*           pCreateInfo,
5228     const VkAllocationCallbacks*                pAllocator,
5229     VkDisplayModeKHR*                           pMode);
5230 
5231 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
5232     VkPhysicalDevice                            physicalDevice,
5233     VkDisplayModeKHR                            mode,
5234     uint32_t                                    planeIndex,
5235     VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
5236 
5237 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
5238     VkInstance                                  instance,
5239     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
5240     const VkAllocationCallbacks*                pAllocator,
5241     VkSurfaceKHR*                               pSurface);
5242 #endif
5243 
5244 
5245 #define VK_KHR_display_swapchain 1
5246 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10
5247 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
5248 typedef struct VkDisplayPresentInfoKHR {
5249     VkStructureType    sType;
5250     const void*        pNext;
5251     VkRect2D           srcRect;
5252     VkRect2D           dstRect;
5253     VkBool32           persistent;
5254 } VkDisplayPresentInfoKHR;
5255 
5256 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
5257 
5258 #ifndef VK_NO_PROTOTYPES
5259 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
5260     VkDevice                                    device,
5261     uint32_t                                    swapchainCount,
5262     const VkSwapchainCreateInfoKHR*             pCreateInfos,
5263     const VkAllocationCallbacks*                pAllocator,
5264     VkSwapchainKHR*                             pSwapchains);
5265 #endif
5266 
5267 
5268 #define VK_KHR_sampler_mirror_clamp_to_edge 1
5269 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3
5270 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
5271 
5272 
5273 #define VK_KHR_multiview 1
5274 #define VK_KHR_MULTIVIEW_SPEC_VERSION     1
5275 #define VK_KHR_MULTIVIEW_EXTENSION_NAME   "VK_KHR_multiview"
5276 typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
5277 
5278 typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;
5279 
5280 typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;
5281 
5282 
5283 
5284 #define VK_KHR_get_physical_device_properties2 1
5285 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2
5286 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
5287 typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
5288 
5289 typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
5290 
5291 typedef VkFormatProperties2 VkFormatProperties2KHR;
5292 
5293 typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
5294 
5295 typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;
5296 
5297 typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
5298 
5299 typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;
5300 
5301 typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
5302 
5303 typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;
5304 
5305 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
5306 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
5307 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
5308 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
5309 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
5310 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
5311 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
5312 
5313 #ifndef VK_NO_PROTOTYPES
5314 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
5315     VkPhysicalDevice                            physicalDevice,
5316     VkPhysicalDeviceFeatures2*                  pFeatures);
5317 
5318 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
5319     VkPhysicalDevice                            physicalDevice,
5320     VkPhysicalDeviceProperties2*                pProperties);
5321 
5322 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
5323     VkPhysicalDevice                            physicalDevice,
5324     VkFormat                                    format,
5325     VkFormatProperties2*                        pFormatProperties);
5326 
5327 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
5328     VkPhysicalDevice                            physicalDevice,
5329     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
5330     VkImageFormatProperties2*                   pImageFormatProperties);
5331 
5332 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
5333     VkPhysicalDevice                            physicalDevice,
5334     uint32_t*                                   pQueueFamilyPropertyCount,
5335     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
5336 
5337 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
5338     VkPhysicalDevice                            physicalDevice,
5339     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
5340 
5341 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
5342     VkPhysicalDevice                            physicalDevice,
5343     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
5344     uint32_t*                                   pPropertyCount,
5345     VkSparseImageFormatProperties2*             pProperties);
5346 #endif
5347 
5348 
5349 #define VK_KHR_device_group 1
5350 #define VK_KHR_DEVICE_GROUP_SPEC_VERSION  4
5351 #define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"
5352 typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
5353 
5354 typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;
5355 
5356 typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;
5357 
5358 typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;
5359 
5360 typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
5361 
5362 typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;
5363 
5364 typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;
5365 
5366 typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
5367 
5368 typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
5369 
5370 typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;
5371 
5372 typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;
5373 
5374 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
5375 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
5376 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);
5377 
5378 #ifndef VK_NO_PROTOTYPES
5379 VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(
5380     VkDevice                                    device,
5381     uint32_t                                    heapIndex,
5382     uint32_t                                    localDeviceIndex,
5383     uint32_t                                    remoteDeviceIndex,
5384     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
5385 
5386 VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(
5387     VkCommandBuffer                             commandBuffer,
5388     uint32_t                                    deviceMask);
5389 
5390 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(
5391     VkCommandBuffer                             commandBuffer,
5392     uint32_t                                    baseGroupX,
5393     uint32_t                                    baseGroupY,
5394     uint32_t                                    baseGroupZ,
5395     uint32_t                                    groupCountX,
5396     uint32_t                                    groupCountY,
5397     uint32_t                                    groupCountZ);
5398 #endif
5399 
5400 
5401 #define VK_KHR_shader_draw_parameters 1
5402 #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
5403 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
5404 
5405 
5406 #define VK_KHR_maintenance1 1
5407 #define VK_KHR_MAINTENANCE1_SPEC_VERSION  2
5408 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
5409 typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;
5410 
5411 typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
5412 
5413 #ifndef VK_NO_PROTOTYPES
5414 VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
5415     VkDevice                                    device,
5416     VkCommandPool                               commandPool,
5417     VkCommandPoolTrimFlags                      flags);
5418 #endif
5419 
5420 
5421 #define VK_KHR_device_group_creation 1
5422 #define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1
5423 #define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"
5424 #define VK_MAX_DEVICE_GROUP_SIZE_KHR      VK_MAX_DEVICE_GROUP_SIZE
5425 typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
5426 
5427 typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
5428 
5429 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
5430 
5431 #ifndef VK_NO_PROTOTYPES
5432 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(
5433     VkInstance                                  instance,
5434     uint32_t*                                   pPhysicalDeviceGroupCount,
5435     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
5436 #endif
5437 
5438 
5439 #define VK_KHR_external_memory_capabilities 1
5440 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
5441 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
5442 #define VK_LUID_SIZE_KHR                  VK_LUID_SIZE
5443 typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;
5444 
5445 typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;
5446 
5447 typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;
5448 
5449 typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;
5450 
5451 typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
5452 
5453 typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;
5454 
5455 typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
5456 
5457 typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;
5458 
5459 typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
5460 
5461 typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
5462 
5463 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
5464 
5465 #ifndef VK_NO_PROTOTYPES
5466 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
5467     VkPhysicalDevice                            physicalDevice,
5468     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
5469     VkExternalBufferProperties*                 pExternalBufferProperties);
5470 #endif
5471 
5472 
5473 #define VK_KHR_external_memory 1
5474 #define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
5475 #define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
5476 #define VK_QUEUE_FAMILY_EXTERNAL_KHR      VK_QUEUE_FAMILY_EXTERNAL
5477 typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
5478 
5479 typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;
5480 
5481 typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
5482 
5483 
5484 
5485 #define VK_KHR_external_memory_fd 1
5486 #define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
5487 #define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
5488 typedef struct VkImportMemoryFdInfoKHR {
5489     VkStructureType                       sType;
5490     const void*                           pNext;
5491     VkExternalMemoryHandleTypeFlagBits    handleType;
5492     int                                   fd;
5493 } VkImportMemoryFdInfoKHR;
5494 
5495 typedef struct VkMemoryFdPropertiesKHR {
5496     VkStructureType    sType;
5497     void*              pNext;
5498     uint32_t           memoryTypeBits;
5499 } VkMemoryFdPropertiesKHR;
5500 
5501 typedef struct VkMemoryGetFdInfoKHR {
5502     VkStructureType                       sType;
5503     const void*                           pNext;
5504     VkDeviceMemory                        memory;
5505     VkExternalMemoryHandleTypeFlagBits    handleType;
5506 } VkMemoryGetFdInfoKHR;
5507 
5508 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
5509 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
5510 
5511 #ifndef VK_NO_PROTOTYPES
5512 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
5513     VkDevice                                    device,
5514     const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
5515     int*                                        pFd);
5516 
5517 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
5518     VkDevice                                    device,
5519     VkExternalMemoryHandleTypeFlagBits          handleType,
5520     int                                         fd,
5521     VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
5522 #endif
5523 
5524 
5525 #define VK_KHR_external_semaphore_capabilities 1
5526 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
5527 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
5528 typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;
5529 
5530 typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;
5531 
5532 typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;
5533 
5534 typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;
5535 
5536 typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;
5537 
5538 typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
5539 
5540 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
5541 
5542 #ifndef VK_NO_PROTOTYPES
5543 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
5544     VkPhysicalDevice                            physicalDevice,
5545     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
5546     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
5547 #endif
5548 
5549 
5550 #define VK_KHR_external_semaphore 1
5551 #define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
5552 #define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
5553 typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;
5554 
5555 typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;
5556 
5557 typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
5558 
5559 
5560 
5561 #define VK_KHR_external_semaphore_fd 1
5562 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
5563 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
5564 typedef struct VkImportSemaphoreFdInfoKHR {
5565     VkStructureType                          sType;
5566     const void*                              pNext;
5567     VkSemaphore                              semaphore;
5568     VkSemaphoreImportFlags                   flags;
5569     VkExternalSemaphoreHandleTypeFlagBits    handleType;
5570     int                                      fd;
5571 } VkImportSemaphoreFdInfoKHR;
5572 
5573 typedef struct VkSemaphoreGetFdInfoKHR {
5574     VkStructureType                          sType;
5575     const void*                              pNext;
5576     VkSemaphore                              semaphore;
5577     VkExternalSemaphoreHandleTypeFlagBits    handleType;
5578 } VkSemaphoreGetFdInfoKHR;
5579 
5580 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
5581 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
5582 
5583 #ifndef VK_NO_PROTOTYPES
5584 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
5585     VkDevice                                    device,
5586     const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
5587 
5588 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
5589     VkDevice                                    device,
5590     const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
5591     int*                                        pFd);
5592 #endif
5593 
5594 
5595 #define VK_KHR_push_descriptor 1
5596 #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
5597 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
5598 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
5599     VkStructureType    sType;
5600     void*              pNext;
5601     uint32_t           maxPushDescriptors;
5602 } VkPhysicalDevicePushDescriptorPropertiesKHR;
5603 
5604 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
5605 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
5606 
5607 #ifndef VK_NO_PROTOTYPES
5608 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
5609     VkCommandBuffer                             commandBuffer,
5610     VkPipelineBindPoint                         pipelineBindPoint,
5611     VkPipelineLayout                            layout,
5612     uint32_t                                    set,
5613     uint32_t                                    descriptorWriteCount,
5614     const VkWriteDescriptorSet*                 pDescriptorWrites);
5615 
5616 VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
5617     VkCommandBuffer                             commandBuffer,
5618     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5619     VkPipelineLayout                            layout,
5620     uint32_t                                    set,
5621     const void*                                 pData);
5622 #endif
5623 
5624 
5625 #define VK_KHR_shader_float16_int8 1
5626 #define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
5627 #define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
5628 typedef struct VkPhysicalDeviceShaderFloat16Int8FeaturesKHR {
5629     VkStructureType    sType;
5630     void*              pNext;
5631     VkBool32           shaderFloat16;
5632     VkBool32           shaderInt8;
5633 } VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
5634 
5635 typedef VkPhysicalDeviceShaderFloat16Int8FeaturesKHR VkPhysicalDeviceFloat16Int8FeaturesKHR;
5636 
5637 
5638 
5639 #define VK_KHR_16bit_storage 1
5640 #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
5641 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
5642 typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;
5643 
5644 
5645 
5646 #define VK_KHR_incremental_present 1
5647 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
5648 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
5649 typedef struct VkRectLayerKHR {
5650     VkOffset2D    offset;
5651     VkExtent2D    extent;
5652     uint32_t      layer;
5653 } VkRectLayerKHR;
5654 
5655 typedef struct VkPresentRegionKHR {
5656     uint32_t                 rectangleCount;
5657     const VkRectLayerKHR*    pRectangles;
5658 } VkPresentRegionKHR;
5659 
5660 typedef struct VkPresentRegionsKHR {
5661     VkStructureType              sType;
5662     const void*                  pNext;
5663     uint32_t                     swapchainCount;
5664     const VkPresentRegionKHR*    pRegions;
5665 } VkPresentRegionsKHR;
5666 
5667 
5668 
5669 #define VK_KHR_descriptor_update_template 1
5670 typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;
5671 
5672 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
5673 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
5674 typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;
5675 
5676 typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
5677 
5678 typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
5679 
5680 typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;
5681 
5682 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
5683 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
5684 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
5685 
5686 #ifndef VK_NO_PROTOTYPES
5687 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
5688     VkDevice                                    device,
5689     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
5690     const VkAllocationCallbacks*                pAllocator,
5691     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
5692 
5693 VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
5694     VkDevice                                    device,
5695     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5696     const VkAllocationCallbacks*                pAllocator);
5697 
5698 VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
5699     VkDevice                                    device,
5700     VkDescriptorSet                             descriptorSet,
5701     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
5702     const void*                                 pData);
5703 #endif
5704 
5705 
5706 #define VK_KHR_imageless_framebuffer 1
5707 #define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1
5708 #define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer"
5709 typedef struct VkPhysicalDeviceImagelessFramebufferFeaturesKHR {
5710     VkStructureType    sType;
5711     void*              pNext;
5712     VkBool32           imagelessFramebuffer;
5713 } VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
5714 
5715 typedef struct VkFramebufferAttachmentImageInfoKHR {
5716     VkStructureType       sType;
5717     const void*           pNext;
5718     VkImageCreateFlags    flags;
5719     VkImageUsageFlags     usage;
5720     uint32_t              width;
5721     uint32_t              height;
5722     uint32_t              layerCount;
5723     uint32_t              viewFormatCount;
5724     const VkFormat*       pViewFormats;
5725 } VkFramebufferAttachmentImageInfoKHR;
5726 
5727 typedef struct VkFramebufferAttachmentsCreateInfoKHR {
5728     VkStructureType                               sType;
5729     const void*                                   pNext;
5730     uint32_t                                      attachmentImageInfoCount;
5731     const VkFramebufferAttachmentImageInfoKHR*    pAttachmentImageInfos;
5732 } VkFramebufferAttachmentsCreateInfoKHR;
5733 
5734 typedef struct VkRenderPassAttachmentBeginInfoKHR {
5735     VkStructureType       sType;
5736     const void*           pNext;
5737     uint32_t              attachmentCount;
5738     const VkImageView*    pAttachments;
5739 } VkRenderPassAttachmentBeginInfoKHR;
5740 
5741 
5742 
5743 #define VK_KHR_create_renderpass2 1
5744 #define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1
5745 #define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"
5746 typedef struct VkAttachmentDescription2KHR {
5747     VkStructureType                 sType;
5748     const void*                     pNext;
5749     VkAttachmentDescriptionFlags    flags;
5750     VkFormat                        format;
5751     VkSampleCountFlagBits           samples;
5752     VkAttachmentLoadOp              loadOp;
5753     VkAttachmentStoreOp             storeOp;
5754     VkAttachmentLoadOp              stencilLoadOp;
5755     VkAttachmentStoreOp             stencilStoreOp;
5756     VkImageLayout                   initialLayout;
5757     VkImageLayout                   finalLayout;
5758 } VkAttachmentDescription2KHR;
5759 
5760 typedef struct VkAttachmentReference2KHR {
5761     VkStructureType       sType;
5762     const void*           pNext;
5763     uint32_t              attachment;
5764     VkImageLayout         layout;
5765     VkImageAspectFlags    aspectMask;
5766 } VkAttachmentReference2KHR;
5767 
5768 typedef struct VkSubpassDescription2KHR {
5769     VkStructureType                     sType;
5770     const void*                         pNext;
5771     VkSubpassDescriptionFlags           flags;
5772     VkPipelineBindPoint                 pipelineBindPoint;
5773     uint32_t                            viewMask;
5774     uint32_t                            inputAttachmentCount;
5775     const VkAttachmentReference2KHR*    pInputAttachments;
5776     uint32_t                            colorAttachmentCount;
5777     const VkAttachmentReference2KHR*    pColorAttachments;
5778     const VkAttachmentReference2KHR*    pResolveAttachments;
5779     const VkAttachmentReference2KHR*    pDepthStencilAttachment;
5780     uint32_t                            preserveAttachmentCount;
5781     const uint32_t*                     pPreserveAttachments;
5782 } VkSubpassDescription2KHR;
5783 
5784 typedef struct VkSubpassDependency2KHR {
5785     VkStructureType         sType;
5786     const void*             pNext;
5787     uint32_t                srcSubpass;
5788     uint32_t                dstSubpass;
5789     VkPipelineStageFlags    srcStageMask;
5790     VkPipelineStageFlags    dstStageMask;
5791     VkAccessFlags           srcAccessMask;
5792     VkAccessFlags           dstAccessMask;
5793     VkDependencyFlags       dependencyFlags;
5794     int32_t                 viewOffset;
5795 } VkSubpassDependency2KHR;
5796 
5797 typedef struct VkRenderPassCreateInfo2KHR {
5798     VkStructureType                       sType;
5799     const void*                           pNext;
5800     VkRenderPassCreateFlags               flags;
5801     uint32_t                              attachmentCount;
5802     const VkAttachmentDescription2KHR*    pAttachments;
5803     uint32_t                              subpassCount;
5804     const VkSubpassDescription2KHR*       pSubpasses;
5805     uint32_t                              dependencyCount;
5806     const VkSubpassDependency2KHR*        pDependencies;
5807     uint32_t                              correlatedViewMaskCount;
5808     const uint32_t*                       pCorrelatedViewMasks;
5809 } VkRenderPassCreateInfo2KHR;
5810 
5811 typedef struct VkSubpassBeginInfoKHR {
5812     VkStructureType      sType;
5813     const void*          pNext;
5814     VkSubpassContents    contents;
5815 } VkSubpassBeginInfoKHR;
5816 
5817 typedef struct VkSubpassEndInfoKHR {
5818     VkStructureType    sType;
5819     const void*        pNext;
5820 } VkSubpassEndInfoKHR;
5821 
5822 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
5823 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfoKHR*      pSubpassBeginInfo);
5824 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR*      pSubpassBeginInfo, const VkSubpassEndInfoKHR*        pSubpassEndInfo);
5825 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR*        pSubpassEndInfo);
5826 
5827 #ifndef VK_NO_PROTOTYPES
5828 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(
5829     VkDevice                                    device,
5830     const VkRenderPassCreateInfo2KHR*           pCreateInfo,
5831     const VkAllocationCallbacks*                pAllocator,
5832     VkRenderPass*                               pRenderPass);
5833 
5834 VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(
5835     VkCommandBuffer                             commandBuffer,
5836     const VkRenderPassBeginInfo*                pRenderPassBegin,
5837     const VkSubpassBeginInfoKHR*                pSubpassBeginInfo);
5838 
5839 VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(
5840     VkCommandBuffer                             commandBuffer,
5841     const VkSubpassBeginInfoKHR*                pSubpassBeginInfo,
5842     const VkSubpassEndInfoKHR*                  pSubpassEndInfo);
5843 
5844 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(
5845     VkCommandBuffer                             commandBuffer,
5846     const VkSubpassEndInfoKHR*                  pSubpassEndInfo);
5847 #endif
5848 
5849 
5850 #define VK_KHR_shared_presentable_image 1
5851 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
5852 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
5853 typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
5854     VkStructureType      sType;
5855     void*                pNext;
5856     VkImageUsageFlags    sharedPresentSupportedUsageFlags;
5857 } VkSharedPresentSurfaceCapabilitiesKHR;
5858 
5859 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
5860 
5861 #ifndef VK_NO_PROTOTYPES
5862 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
5863     VkDevice                                    device,
5864     VkSwapchainKHR                              swapchain);
5865 #endif
5866 
5867 
5868 #define VK_KHR_external_fence_capabilities 1
5869 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
5870 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
5871 typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;
5872 
5873 typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;
5874 
5875 typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;
5876 
5877 typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;
5878 
5879 typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;
5880 
5881 typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
5882 
5883 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
5884 
5885 #ifndef VK_NO_PROTOTYPES
5886 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
5887     VkPhysicalDevice                            physicalDevice,
5888     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
5889     VkExternalFenceProperties*                  pExternalFenceProperties);
5890 #endif
5891 
5892 
5893 #define VK_KHR_external_fence 1
5894 #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
5895 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
5896 typedef VkFenceImportFlags VkFenceImportFlagsKHR;
5897 
5898 typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;
5899 
5900 typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
5901 
5902 
5903 
5904 #define VK_KHR_external_fence_fd 1
5905 #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
5906 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
5907 typedef struct VkImportFenceFdInfoKHR {
5908     VkStructureType                      sType;
5909     const void*                          pNext;
5910     VkFence                              fence;
5911     VkFenceImportFlags                   flags;
5912     VkExternalFenceHandleTypeFlagBits    handleType;
5913     int                                  fd;
5914 } VkImportFenceFdInfoKHR;
5915 
5916 typedef struct VkFenceGetFdInfoKHR {
5917     VkStructureType                      sType;
5918     const void*                          pNext;
5919     VkFence                              fence;
5920     VkExternalFenceHandleTypeFlagBits    handleType;
5921 } VkFenceGetFdInfoKHR;
5922 
5923 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
5924 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
5925 
5926 #ifndef VK_NO_PROTOTYPES
5927 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
5928     VkDevice                                    device,
5929     const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
5930 
5931 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
5932     VkDevice                                    device,
5933     const VkFenceGetFdInfoKHR*                  pGetFdInfo,
5934     int*                                        pFd);
5935 #endif
5936 
5937 
5938 #define VK_KHR_performance_query 1
5939 #define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1
5940 #define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"
5941 
5942 typedef enum VkPerformanceCounterUnitKHR {
5943     VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
5944     VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
5945     VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
5946     VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
5947     VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
5948     VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
5949     VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
5950     VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
5951     VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
5952     VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
5953     VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
5954     VK_PERFORMANCE_COUNTER_UNIT_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR,
5955     VK_PERFORMANCE_COUNTER_UNIT_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR,
5956     VK_PERFORMANCE_COUNTER_UNIT_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR - VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR + 1),
5957     VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF
5958 } VkPerformanceCounterUnitKHR;
5959 
5960 typedef enum VkPerformanceCounterScopeKHR {
5961     VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = 0,
5962     VK_QUERY_SCOPE_RENDER_PASS_KHR = 1,
5963     VK_QUERY_SCOPE_COMMAND_KHR = 2,
5964     VK_PERFORMANCE_COUNTER_SCOPE_BEGIN_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR,
5965     VK_PERFORMANCE_COUNTER_SCOPE_END_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_KHR,
5966     VK_PERFORMANCE_COUNTER_SCOPE_RANGE_SIZE_KHR = (VK_QUERY_SCOPE_COMMAND_KHR - VK_QUERY_SCOPE_COMMAND_BUFFER_KHR + 1),
5967     VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF
5968 } VkPerformanceCounterScopeKHR;
5969 
5970 typedef enum VkPerformanceCounterStorageKHR {
5971     VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
5972     VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
5973     VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
5974     VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
5975     VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
5976     VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
5977     VK_PERFORMANCE_COUNTER_STORAGE_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR,
5978     VK_PERFORMANCE_COUNTER_STORAGE_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR,
5979     VK_PERFORMANCE_COUNTER_STORAGE_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR - VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR + 1),
5980     VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF
5981 } VkPerformanceCounterStorageKHR;
5982 
5983 typedef enum VkPerformanceCounterDescriptionFlagBitsKHR {
5984     VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 0x00000001,
5985     VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 0x00000002,
5986     VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
5987 } VkPerformanceCounterDescriptionFlagBitsKHR;
5988 typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
5989 
5990 typedef enum VkAcquireProfilingLockFlagBitsKHR {
5991     VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
5992 } VkAcquireProfilingLockFlagBitsKHR;
5993 typedef VkFlags VkAcquireProfilingLockFlagsKHR;
5994 typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
5995     VkStructureType    sType;
5996     void*              pNext;
5997     VkBool32           performanceCounterQueryPools;
5998     VkBool32           performanceCounterMultipleQueryPools;
5999 } VkPhysicalDevicePerformanceQueryFeaturesKHR;
6000 
6001 typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
6002     VkStructureType    sType;
6003     void*              pNext;
6004     VkBool32           allowCommandBufferQueryCopies;
6005 } VkPhysicalDevicePerformanceQueryPropertiesKHR;
6006 
6007 typedef struct VkPerformanceCounterKHR {
6008     VkStructureType                   sType;
6009     const void*                       pNext;
6010     VkPerformanceCounterUnitKHR       unit;
6011     VkPerformanceCounterScopeKHR      scope;
6012     VkPerformanceCounterStorageKHR    storage;
6013     uint8_t                           uuid[VK_UUID_SIZE];
6014 } VkPerformanceCounterKHR;
6015 
6016 typedef struct VkPerformanceCounterDescriptionKHR {
6017     VkStructureType                            sType;
6018     const void*                                pNext;
6019     VkPerformanceCounterDescriptionFlagsKHR    flags;
6020     char                                       name[VK_MAX_DESCRIPTION_SIZE];
6021     char                                       category[VK_MAX_DESCRIPTION_SIZE];
6022     char                                       description[VK_MAX_DESCRIPTION_SIZE];
6023 } VkPerformanceCounterDescriptionKHR;
6024 
6025 typedef struct VkQueryPoolPerformanceCreateInfoKHR {
6026     VkStructureType    sType;
6027     const void*        pNext;
6028     uint32_t           queueFamilyIndex;
6029     uint32_t           counterIndexCount;
6030     const uint32_t*    pCounterIndices;
6031 } VkQueryPoolPerformanceCreateInfoKHR;
6032 
6033 typedef union VkPerformanceCounterResultKHR {
6034     int32_t     int32;
6035     int64_t     int64;
6036     uint32_t    uint32;
6037     uint64_t    uint64;
6038     float       float32;
6039     double      float64;
6040 } VkPerformanceCounterResultKHR;
6041 
6042 typedef struct VkAcquireProfilingLockInfoKHR {
6043     VkStructureType                   sType;
6044     const void*                       pNext;
6045     VkAcquireProfilingLockFlagsKHR    flags;
6046     uint64_t                          timeout;
6047 } VkAcquireProfilingLockInfoKHR;
6048 
6049 typedef struct VkPerformanceQuerySubmitInfoKHR {
6050     VkStructureType    sType;
6051     const void*        pNext;
6052     uint32_t           counterPassIndex;
6053 } VkPerformanceQuerySubmitInfoKHR;
6054 
6055 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
6056 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses);
6057 typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);
6058 typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device);
6059 
6060 #ifndef VK_NO_PROTOTYPES
6061 VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
6062     VkPhysicalDevice                            physicalDevice,
6063     uint32_t                                    queueFamilyIndex,
6064     uint32_t*                                   pCounterCount,
6065     VkPerformanceCounterKHR*                    pCounters,
6066     VkPerformanceCounterDescriptionKHR*         pCounterDescriptions);
6067 
6068 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
6069     VkPhysicalDevice                            physicalDevice,
6070     const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
6071     uint32_t*                                   pNumPasses);
6072 
6073 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(
6074     VkDevice                                    device,
6075     const VkAcquireProfilingLockInfoKHR*        pInfo);
6076 
6077 VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(
6078     VkDevice                                    device);
6079 #endif
6080 
6081 
6082 #define VK_KHR_maintenance2 1
6083 #define VK_KHR_MAINTENANCE2_SPEC_VERSION  1
6084 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"
6085 typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;
6086 
6087 typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;
6088 
6089 typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;
6090 
6091 typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;
6092 
6093 typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;
6094 
6095 typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
6096 
6097 typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;
6098 
6099 
6100 
6101 #define VK_KHR_get_surface_capabilities2 1
6102 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
6103 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
6104 typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
6105     VkStructureType    sType;
6106     const void*        pNext;
6107     VkSurfaceKHR       surface;
6108 } VkPhysicalDeviceSurfaceInfo2KHR;
6109 
6110 typedef struct VkSurfaceCapabilities2KHR {
6111     VkStructureType             sType;
6112     void*                       pNext;
6113     VkSurfaceCapabilitiesKHR    surfaceCapabilities;
6114 } VkSurfaceCapabilities2KHR;
6115 
6116 typedef struct VkSurfaceFormat2KHR {
6117     VkStructureType       sType;
6118     void*                 pNext;
6119     VkSurfaceFormatKHR    surfaceFormat;
6120 } VkSurfaceFormat2KHR;
6121 
6122 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
6123 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
6124 
6125 #ifndef VK_NO_PROTOTYPES
6126 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
6127     VkPhysicalDevice                            physicalDevice,
6128     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
6129     VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
6130 
6131 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
6132     VkPhysicalDevice                            physicalDevice,
6133     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
6134     uint32_t*                                   pSurfaceFormatCount,
6135     VkSurfaceFormat2KHR*                        pSurfaceFormats);
6136 #endif
6137 
6138 
6139 #define VK_KHR_variable_pointers 1
6140 #define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
6141 #define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
6142 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;
6143 
6144 typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;
6145 
6146 
6147 
6148 #define VK_KHR_get_display_properties2 1
6149 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1
6150 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"
6151 typedef struct VkDisplayProperties2KHR {
6152     VkStructureType           sType;
6153     void*                     pNext;
6154     VkDisplayPropertiesKHR    displayProperties;
6155 } VkDisplayProperties2KHR;
6156 
6157 typedef struct VkDisplayPlaneProperties2KHR {
6158     VkStructureType                sType;
6159     void*                          pNext;
6160     VkDisplayPlanePropertiesKHR    displayPlaneProperties;
6161 } VkDisplayPlaneProperties2KHR;
6162 
6163 typedef struct VkDisplayModeProperties2KHR {
6164     VkStructureType               sType;
6165     void*                         pNext;
6166     VkDisplayModePropertiesKHR    displayModeProperties;
6167 } VkDisplayModeProperties2KHR;
6168 
6169 typedef struct VkDisplayPlaneInfo2KHR {
6170     VkStructureType     sType;
6171     const void*         pNext;
6172     VkDisplayModeKHR    mode;
6173     uint32_t            planeIndex;
6174 } VkDisplayPlaneInfo2KHR;
6175 
6176 typedef struct VkDisplayPlaneCapabilities2KHR {
6177     VkStructureType                  sType;
6178     void*                            pNext;
6179     VkDisplayPlaneCapabilitiesKHR    capabilities;
6180 } VkDisplayPlaneCapabilities2KHR;
6181 
6182 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties);
6183 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties);
6184 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties);
6185 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities);
6186 
6187 #ifndef VK_NO_PROTOTYPES
6188 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(
6189     VkPhysicalDevice                            physicalDevice,
6190     uint32_t*                                   pPropertyCount,
6191     VkDisplayProperties2KHR*                    pProperties);
6192 
6193 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
6194     VkPhysicalDevice                            physicalDevice,
6195     uint32_t*                                   pPropertyCount,
6196     VkDisplayPlaneProperties2KHR*               pProperties);
6197 
6198 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(
6199     VkPhysicalDevice                            physicalDevice,
6200     VkDisplayKHR                                display,
6201     uint32_t*                                   pPropertyCount,
6202     VkDisplayModeProperties2KHR*                pProperties);
6203 
6204 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(
6205     VkPhysicalDevice                            physicalDevice,
6206     const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
6207     VkDisplayPlaneCapabilities2KHR*             pCapabilities);
6208 #endif
6209 
6210 
6211 #define VK_KHR_dedicated_allocation 1
6212 #define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
6213 #define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
6214 typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
6215 
6216 typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
6217 
6218 
6219 
6220 #define VK_KHR_storage_buffer_storage_class 1
6221 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
6222 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
6223 
6224 
6225 #define VK_KHR_relaxed_block_layout 1
6226 #define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
6227 #define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
6228 
6229 
6230 #define VK_KHR_get_memory_requirements2 1
6231 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
6232 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
6233 typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
6234 
6235 typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
6236 
6237 typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
6238 
6239 typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
6240 
6241 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
6242 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
6243 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
6244 
6245 #ifndef VK_NO_PROTOTYPES
6246 VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
6247     VkDevice                                    device,
6248     const VkImageMemoryRequirementsInfo2*       pInfo,
6249     VkMemoryRequirements2*                      pMemoryRequirements);
6250 
6251 VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
6252     VkDevice                                    device,
6253     const VkBufferMemoryRequirementsInfo2*      pInfo,
6254     VkMemoryRequirements2*                      pMemoryRequirements);
6255 
6256 VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
6257     VkDevice                                    device,
6258     const VkImageSparseMemoryRequirementsInfo2* pInfo,
6259     uint32_t*                                   pSparseMemoryRequirementCount,
6260     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
6261 #endif
6262 
6263 
6264 #define VK_KHR_image_format_list 1
6265 #define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
6266 #define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"
6267 typedef struct VkImageFormatListCreateInfoKHR {
6268     VkStructureType    sType;
6269     const void*        pNext;
6270     uint32_t           viewFormatCount;
6271     const VkFormat*    pViewFormats;
6272 } VkImageFormatListCreateInfoKHR;
6273 
6274 
6275 
6276 #define VK_KHR_sampler_ycbcr_conversion 1
6277 typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
6278 
6279 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14
6280 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
6281 typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
6282 
6283 typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
6284 
6285 typedef VkChromaLocation VkChromaLocationKHR;
6286 
6287 typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;
6288 
6289 typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
6290 
6291 typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
6292 
6293 typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;
6294 
6295 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
6296 
6297 typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;
6298 
6299 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
6300 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
6301 
6302 #ifndef VK_NO_PROTOTYPES
6303 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(
6304     VkDevice                                    device,
6305     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
6306     const VkAllocationCallbacks*                pAllocator,
6307     VkSamplerYcbcrConversion*                   pYcbcrConversion);
6308 
6309 VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(
6310     VkDevice                                    device,
6311     VkSamplerYcbcrConversion                    ycbcrConversion,
6312     const VkAllocationCallbacks*                pAllocator);
6313 #endif
6314 
6315 
6316 #define VK_KHR_bind_memory2 1
6317 #define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1
6318 #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"
6319 typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
6320 
6321 typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
6322 
6323 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
6324 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
6325 
6326 #ifndef VK_NO_PROTOTYPES
6327 VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(
6328     VkDevice                                    device,
6329     uint32_t                                    bindInfoCount,
6330     const VkBindBufferMemoryInfo*               pBindInfos);
6331 
6332 VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(
6333     VkDevice                                    device,
6334     uint32_t                                    bindInfoCount,
6335     const VkBindImageMemoryInfo*                pBindInfos);
6336 #endif
6337 
6338 
6339 #define VK_KHR_maintenance3 1
6340 #define VK_KHR_MAINTENANCE3_SPEC_VERSION  1
6341 #define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3"
6342 typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
6343 
6344 typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
6345 
6346 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
6347 
6348 #ifndef VK_NO_PROTOTYPES
6349 VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(
6350     VkDevice                                    device,
6351     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
6352     VkDescriptorSetLayoutSupport*               pSupport);
6353 #endif
6354 
6355 
6356 #define VK_KHR_draw_indirect_count 1
6357 #define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
6358 #define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count"
6359 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
6360 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
6361 
6362 #ifndef VK_NO_PROTOTYPES
6363 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(
6364     VkCommandBuffer                             commandBuffer,
6365     VkBuffer                                    buffer,
6366     VkDeviceSize                                offset,
6367     VkBuffer                                    countBuffer,
6368     VkDeviceSize                                countBufferOffset,
6369     uint32_t                                    maxDrawCount,
6370     uint32_t                                    stride);
6371 
6372 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(
6373     VkCommandBuffer                             commandBuffer,
6374     VkBuffer                                    buffer,
6375     VkDeviceSize                                offset,
6376     VkBuffer                                    countBuffer,
6377     VkDeviceSize                                countBufferOffset,
6378     uint32_t                                    maxDrawCount,
6379     uint32_t                                    stride);
6380 #endif
6381 
6382 
6383 #define VK_KHR_shader_subgroup_extended_types 1
6384 #define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1
6385 #define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types"
6386 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR {
6387     VkStructureType    sType;
6388     void*              pNext;
6389     VkBool32           shaderSubgroupExtendedTypes;
6390 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
6391 
6392 
6393 
6394 #define VK_KHR_8bit_storage 1
6395 #define VK_KHR_8BIT_STORAGE_SPEC_VERSION  1
6396 #define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
6397 typedef struct VkPhysicalDevice8BitStorageFeaturesKHR {
6398     VkStructureType    sType;
6399     void*              pNext;
6400     VkBool32           storageBuffer8BitAccess;
6401     VkBool32           uniformAndStorageBuffer8BitAccess;
6402     VkBool32           storagePushConstant8;
6403 } VkPhysicalDevice8BitStorageFeaturesKHR;
6404 
6405 
6406 
6407 #define VK_KHR_shader_atomic_int64 1
6408 #define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1
6409 #define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"
6410 typedef struct VkPhysicalDeviceShaderAtomicInt64FeaturesKHR {
6411     VkStructureType    sType;
6412     void*              pNext;
6413     VkBool32           shaderBufferInt64Atomics;
6414     VkBool32           shaderSharedInt64Atomics;
6415 } VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;
6416 
6417 
6418 
6419 #define VK_KHR_shader_clock 1
6420 #define VK_KHR_SHADER_CLOCK_SPEC_VERSION  1
6421 #define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
6422 typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
6423     VkStructureType    sType;
6424     void*              pNext;
6425     VkBool32           shaderSubgroupClock;
6426     VkBool32           shaderDeviceClock;
6427 } VkPhysicalDeviceShaderClockFeaturesKHR;
6428 
6429 
6430 
6431 #define VK_KHR_driver_properties 1
6432 #define VK_MAX_DRIVER_NAME_SIZE_KHR       256
6433 #define VK_MAX_DRIVER_INFO_SIZE_KHR       256
6434 #define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1
6435 #define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties"
6436 
6437 typedef enum VkDriverIdKHR {
6438     VK_DRIVER_ID_AMD_PROPRIETARY_KHR = 1,
6439     VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = 2,
6440     VK_DRIVER_ID_MESA_RADV_KHR = 3,
6441     VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = 4,
6442     VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = 5,
6443     VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = 6,
6444     VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = 7,
6445     VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = 8,
6446     VK_DRIVER_ID_ARM_PROPRIETARY_KHR = 9,
6447     VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = 10,
6448     VK_DRIVER_ID_GGP_PROPRIETARY_KHR = 11,
6449     VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = 12,
6450     VK_DRIVER_ID_BEGIN_RANGE_KHR = VK_DRIVER_ID_AMD_PROPRIETARY_KHR,
6451     VK_DRIVER_ID_END_RANGE_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR,
6452     VK_DRIVER_ID_RANGE_SIZE_KHR = (VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR - VK_DRIVER_ID_AMD_PROPRIETARY_KHR + 1),
6453     VK_DRIVER_ID_MAX_ENUM_KHR = 0x7FFFFFFF
6454 } VkDriverIdKHR;
6455 typedef struct VkConformanceVersionKHR {
6456     uint8_t    major;
6457     uint8_t    minor;
6458     uint8_t    subminor;
6459     uint8_t    patch;
6460 } VkConformanceVersionKHR;
6461 
6462 typedef struct VkPhysicalDeviceDriverPropertiesKHR {
6463     VkStructureType            sType;
6464     void*                      pNext;
6465     VkDriverIdKHR              driverID;
6466     char                       driverName[VK_MAX_DRIVER_NAME_SIZE_KHR];
6467     char                       driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR];
6468     VkConformanceVersionKHR    conformanceVersion;
6469 } VkPhysicalDeviceDriverPropertiesKHR;
6470 
6471 
6472 
6473 #define VK_KHR_shader_float_controls 1
6474 #define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4
6475 #define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls"
6476 
6477 typedef enum VkShaderFloatControlsIndependenceKHR {
6478     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = 0,
6479     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = 1,
6480     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = 2,
6481     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_BEGIN_RANGE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR,
6482     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_END_RANGE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR,
6483     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_RANGE_SIZE_KHR = (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR + 1),
6484     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM_KHR = 0x7FFFFFFF
6485 } VkShaderFloatControlsIndependenceKHR;
6486 typedef struct VkPhysicalDeviceFloatControlsPropertiesKHR {
6487     VkStructureType                         sType;
6488     void*                                   pNext;
6489     VkShaderFloatControlsIndependenceKHR    denormBehaviorIndependence;
6490     VkShaderFloatControlsIndependenceKHR    roundingModeIndependence;
6491     VkBool32                                shaderSignedZeroInfNanPreserveFloat16;
6492     VkBool32                                shaderSignedZeroInfNanPreserveFloat32;
6493     VkBool32                                shaderSignedZeroInfNanPreserveFloat64;
6494     VkBool32                                shaderDenormPreserveFloat16;
6495     VkBool32                                shaderDenormPreserveFloat32;
6496     VkBool32                                shaderDenormPreserveFloat64;
6497     VkBool32                                shaderDenormFlushToZeroFloat16;
6498     VkBool32                                shaderDenormFlushToZeroFloat32;
6499     VkBool32                                shaderDenormFlushToZeroFloat64;
6500     VkBool32                                shaderRoundingModeRTEFloat16;
6501     VkBool32                                shaderRoundingModeRTEFloat32;
6502     VkBool32                                shaderRoundingModeRTEFloat64;
6503     VkBool32                                shaderRoundingModeRTZFloat16;
6504     VkBool32                                shaderRoundingModeRTZFloat32;
6505     VkBool32                                shaderRoundingModeRTZFloat64;
6506 } VkPhysicalDeviceFloatControlsPropertiesKHR;
6507 
6508 
6509 
6510 #define VK_KHR_depth_stencil_resolve 1
6511 #define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1
6512 #define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve"
6513 
6514 typedef enum VkResolveModeFlagBitsKHR {
6515     VK_RESOLVE_MODE_NONE_KHR = 0,
6516     VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = 0x00000001,
6517     VK_RESOLVE_MODE_AVERAGE_BIT_KHR = 0x00000002,
6518     VK_RESOLVE_MODE_MIN_BIT_KHR = 0x00000004,
6519     VK_RESOLVE_MODE_MAX_BIT_KHR = 0x00000008,
6520     VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6521 } VkResolveModeFlagBitsKHR;
6522 typedef VkFlags VkResolveModeFlagsKHR;
6523 typedef struct VkSubpassDescriptionDepthStencilResolveKHR {
6524     VkStructureType                     sType;
6525     const void*                         pNext;
6526     VkResolveModeFlagBitsKHR            depthResolveMode;
6527     VkResolveModeFlagBitsKHR            stencilResolveMode;
6528     const VkAttachmentReference2KHR*    pDepthStencilResolveAttachment;
6529 } VkSubpassDescriptionDepthStencilResolveKHR;
6530 
6531 typedef struct VkPhysicalDeviceDepthStencilResolvePropertiesKHR {
6532     VkStructureType          sType;
6533     void*                    pNext;
6534     VkResolveModeFlagsKHR    supportedDepthResolveModes;
6535     VkResolveModeFlagsKHR    supportedStencilResolveModes;
6536     VkBool32                 independentResolveNone;
6537     VkBool32                 independentResolve;
6538 } VkPhysicalDeviceDepthStencilResolvePropertiesKHR;
6539 
6540 
6541 
6542 #define VK_KHR_swapchain_mutable_format 1
6543 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1
6544 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format"
6545 
6546 
6547 #define VK_KHR_timeline_semaphore 1
6548 #define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2
6549 #define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore"
6550 
6551 typedef enum VkSemaphoreTypeKHR {
6552     VK_SEMAPHORE_TYPE_BINARY_KHR = 0,
6553     VK_SEMAPHORE_TYPE_TIMELINE_KHR = 1,
6554     VK_SEMAPHORE_TYPE_BEGIN_RANGE_KHR = VK_SEMAPHORE_TYPE_BINARY_KHR,
6555     VK_SEMAPHORE_TYPE_END_RANGE_KHR = VK_SEMAPHORE_TYPE_TIMELINE_KHR,
6556     VK_SEMAPHORE_TYPE_RANGE_SIZE_KHR = (VK_SEMAPHORE_TYPE_TIMELINE_KHR - VK_SEMAPHORE_TYPE_BINARY_KHR + 1),
6557     VK_SEMAPHORE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
6558 } VkSemaphoreTypeKHR;
6559 
6560 typedef enum VkSemaphoreWaitFlagBitsKHR {
6561     VK_SEMAPHORE_WAIT_ANY_BIT_KHR = 0x00000001,
6562     VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
6563 } VkSemaphoreWaitFlagBitsKHR;
6564 typedef VkFlags VkSemaphoreWaitFlagsKHR;
6565 typedef struct VkPhysicalDeviceTimelineSemaphoreFeaturesKHR {
6566     VkStructureType    sType;
6567     void*              pNext;
6568     VkBool32           timelineSemaphore;
6569 } VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;
6570 
6571 typedef struct VkPhysicalDeviceTimelineSemaphorePropertiesKHR {
6572     VkStructureType    sType;
6573     void*              pNext;
6574     uint64_t           maxTimelineSemaphoreValueDifference;
6575 } VkPhysicalDeviceTimelineSemaphorePropertiesKHR;
6576 
6577 typedef struct VkSemaphoreTypeCreateInfoKHR {
6578     VkStructureType       sType;
6579     const void*           pNext;
6580     VkSemaphoreTypeKHR    semaphoreType;
6581     uint64_t              initialValue;
6582 } VkSemaphoreTypeCreateInfoKHR;
6583 
6584 typedef struct VkTimelineSemaphoreSubmitInfoKHR {
6585     VkStructureType    sType;
6586     const void*        pNext;
6587     uint32_t           waitSemaphoreValueCount;
6588     const uint64_t*    pWaitSemaphoreValues;
6589     uint32_t           signalSemaphoreValueCount;
6590     const uint64_t*    pSignalSemaphoreValues;
6591 } VkTimelineSemaphoreSubmitInfoKHR;
6592 
6593 typedef struct VkSemaphoreWaitInfoKHR {
6594     VkStructureType            sType;
6595     const void*                pNext;
6596     VkSemaphoreWaitFlagsKHR    flags;
6597     uint32_t                   semaphoreCount;
6598     const VkSemaphore*         pSemaphores;
6599     const uint64_t*            pValues;
6600 } VkSemaphoreWaitInfoKHR;
6601 
6602 typedef struct VkSemaphoreSignalInfoKHR {
6603     VkStructureType    sType;
6604     const void*        pNext;
6605     VkSemaphore        semaphore;
6606     uint64_t           value;
6607 } VkSemaphoreSignalInfoKHR;
6608 
6609 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
6610 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout);
6611 typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfoKHR* pSignalInfo);
6612 
6613 #ifndef VK_NO_PROTOTYPES
6614 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(
6615     VkDevice                                    device,
6616     VkSemaphore                                 semaphore,
6617     uint64_t*                                   pValue);
6618 
6619 VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(
6620     VkDevice                                    device,
6621     const VkSemaphoreWaitInfoKHR*               pWaitInfo,
6622     uint64_t                                    timeout);
6623 
6624 VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(
6625     VkDevice                                    device,
6626     const VkSemaphoreSignalInfoKHR*             pSignalInfo);
6627 #endif
6628 
6629 
6630 #define VK_KHR_vulkan_memory_model 1
6631 #define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3
6632 #define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"
6633 typedef struct VkPhysicalDeviceVulkanMemoryModelFeaturesKHR {
6634     VkStructureType    sType;
6635     void*              pNext;
6636     VkBool32           vulkanMemoryModel;
6637     VkBool32           vulkanMemoryModelDeviceScope;
6638     VkBool32           vulkanMemoryModelAvailabilityVisibilityChains;
6639 } VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
6640 
6641 
6642 
6643 #define VK_KHR_spirv_1_4 1
6644 #define VK_KHR_SPIRV_1_4_SPEC_VERSION     1
6645 #define VK_KHR_SPIRV_1_4_EXTENSION_NAME   "VK_KHR_spirv_1_4"
6646 
6647 
6648 #define VK_KHR_surface_protected_capabilities 1
6649 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
6650 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities"
6651 typedef struct VkSurfaceProtectedCapabilitiesKHR {
6652     VkStructureType    sType;
6653     const void*        pNext;
6654     VkBool32           supportsProtected;
6655 } VkSurfaceProtectedCapabilitiesKHR;
6656 
6657 
6658 
6659 #define VK_KHR_separate_depth_stencil_layouts 1
6660 #define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1
6661 #define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts"
6662 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR {
6663     VkStructureType    sType;
6664     void*              pNext;
6665     VkBool32           separateDepthStencilLayouts;
6666 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
6667 
6668 typedef struct VkAttachmentReferenceStencilLayoutKHR {
6669     VkStructureType    sType;
6670     void*              pNext;
6671     VkImageLayout      stencilLayout;
6672 } VkAttachmentReferenceStencilLayoutKHR;
6673 
6674 typedef struct VkAttachmentDescriptionStencilLayoutKHR {
6675     VkStructureType    sType;
6676     void*              pNext;
6677     VkImageLayout      stencilInitialLayout;
6678     VkImageLayout      stencilFinalLayout;
6679 } VkAttachmentDescriptionStencilLayoutKHR;
6680 
6681 
6682 
6683 #define VK_KHR_uniform_buffer_standard_layout 1
6684 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
6685 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout"
6686 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR {
6687     VkStructureType    sType;
6688     void*              pNext;
6689     VkBool32           uniformBufferStandardLayout;
6690 } VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
6691 
6692 
6693 
6694 #define VK_KHR_buffer_device_address 1
6695 typedef uint64_t VkDeviceAddress;
6696 #define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1
6697 #define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address"
6698 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesKHR {
6699     VkStructureType    sType;
6700     void*              pNext;
6701     VkBool32           bufferDeviceAddress;
6702     VkBool32           bufferDeviceAddressCaptureReplay;
6703     VkBool32           bufferDeviceAddressMultiDevice;
6704 } VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;
6705 
6706 typedef struct VkBufferDeviceAddressInfoKHR {
6707     VkStructureType    sType;
6708     const void*        pNext;
6709     VkBuffer           buffer;
6710 } VkBufferDeviceAddressInfoKHR;
6711 
6712 typedef struct VkBufferOpaqueCaptureAddressCreateInfoKHR {
6713     VkStructureType    sType;
6714     const void*        pNext;
6715     uint64_t           opaqueCaptureAddress;
6716 } VkBufferOpaqueCaptureAddressCreateInfoKHR;
6717 
6718 typedef struct VkMemoryOpaqueCaptureAddressAllocateInfoKHR {
6719     VkStructureType    sType;
6720     const void*        pNext;
6721     uint64_t           opaqueCaptureAddress;
6722 } VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
6723 
6724 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfoKHR {
6725     VkStructureType    sType;
6726     const void*        pNext;
6727     VkDeviceMemory     memory;
6728 } VkDeviceMemoryOpaqueCaptureAddressInfoKHR;
6729 
6730 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
6731 typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
6732 typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo);
6733 
6734 #ifndef VK_NO_PROTOTYPES
6735 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(
6736     VkDevice                                    device,
6737     const VkBufferDeviceAddressInfoKHR*         pInfo);
6738 
6739 VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(
6740     VkDevice                                    device,
6741     const VkBufferDeviceAddressInfoKHR*         pInfo);
6742 
6743 VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(
6744     VkDevice                                    device,
6745     const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo);
6746 #endif
6747 
6748 
6749 #define VK_KHR_pipeline_executable_properties 1
6750 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
6751 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
6752 
6753 typedef enum VkPipelineExecutableStatisticFormatKHR {
6754     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,
6755     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,
6756     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,
6757     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,
6758     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BEGIN_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
6759     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_END_RANGE_KHR = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR,
6760     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_RANGE_SIZE_KHR = (VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR + 1),
6761     VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF
6762 } VkPipelineExecutableStatisticFormatKHR;
6763 typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
6764     VkStructureType    sType;
6765     void*              pNext;
6766     VkBool32           pipelineExecutableInfo;
6767 } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
6768 
6769 typedef struct VkPipelineInfoKHR {
6770     VkStructureType    sType;
6771     const void*        pNext;
6772     VkPipeline         pipeline;
6773 } VkPipelineInfoKHR;
6774 
6775 typedef struct VkPipelineExecutablePropertiesKHR {
6776     VkStructureType       sType;
6777     void*                 pNext;
6778     VkShaderStageFlags    stages;
6779     char                  name[VK_MAX_DESCRIPTION_SIZE];
6780     char                  description[VK_MAX_DESCRIPTION_SIZE];
6781     uint32_t              subgroupSize;
6782 } VkPipelineExecutablePropertiesKHR;
6783 
6784 typedef struct VkPipelineExecutableInfoKHR {
6785     VkStructureType    sType;
6786     const void*        pNext;
6787     VkPipeline         pipeline;
6788     uint32_t           executableIndex;
6789 } VkPipelineExecutableInfoKHR;
6790 
6791 typedef union VkPipelineExecutableStatisticValueKHR {
6792     VkBool32    b32;
6793     int64_t     i64;
6794     uint64_t    u64;
6795     double      f64;
6796 } VkPipelineExecutableStatisticValueKHR;
6797 
6798 typedef struct VkPipelineExecutableStatisticKHR {
6799     VkStructureType                           sType;
6800     void*                                     pNext;
6801     char                                      name[VK_MAX_DESCRIPTION_SIZE];
6802     char                                      description[VK_MAX_DESCRIPTION_SIZE];
6803     VkPipelineExecutableStatisticFormatKHR    format;
6804     VkPipelineExecutableStatisticValueKHR     value;
6805 } VkPipelineExecutableStatisticKHR;
6806 
6807 typedef struct VkPipelineExecutableInternalRepresentationKHR {
6808     VkStructureType    sType;
6809     void*              pNext;
6810     char               name[VK_MAX_DESCRIPTION_SIZE];
6811     char               description[VK_MAX_DESCRIPTION_SIZE];
6812     VkBool32           isText;
6813     size_t             dataSize;
6814     void*              pData;
6815 } VkPipelineExecutableInternalRepresentationKHR;
6816 
6817 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
6818 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
6819 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
6820 
6821 #ifndef VK_NO_PROTOTYPES
6822 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(
6823     VkDevice                                    device,
6824     const VkPipelineInfoKHR*                    pPipelineInfo,
6825     uint32_t*                                   pExecutableCount,
6826     VkPipelineExecutablePropertiesKHR*          pProperties);
6827 
6828 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(
6829     VkDevice                                    device,
6830     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
6831     uint32_t*                                   pStatisticCount,
6832     VkPipelineExecutableStatisticKHR*           pStatistics);
6833 
6834 VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(
6835     VkDevice                                    device,
6836     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
6837     uint32_t*                                   pInternalRepresentationCount,
6838     VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
6839 #endif
6840 
6841 
6842 #define VK_EXT_debug_report 1
6843 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
6844 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION  9
6845 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
6846 
6847 typedef enum VkDebugReportObjectTypeEXT {
6848     VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
6849     VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
6850     VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
6851     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
6852     VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
6853     VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
6854     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
6855     VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
6856     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
6857     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
6858     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
6859     VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
6860     VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
6861     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
6862     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
6863     VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
6864     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
6865     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
6866     VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
6867     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
6868     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
6869     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
6870     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
6871     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
6872     VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
6873     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
6874     VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
6875     VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
6876     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
6877     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
6878     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
6879     VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
6880     VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
6881     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,
6882     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,
6883     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000,
6884     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,
6885     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
6886     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
6887     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
6888     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
6889     VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
6890     VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
6891     VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1),
6892     VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
6893 } VkDebugReportObjectTypeEXT;
6894 
6895 typedef enum VkDebugReportFlagBitsEXT {
6896     VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
6897     VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
6898     VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
6899     VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
6900     VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
6901     VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
6902 } VkDebugReportFlagBitsEXT;
6903 typedef VkFlags VkDebugReportFlagsEXT;
6904 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
6905     VkDebugReportFlagsEXT                       flags,
6906     VkDebugReportObjectTypeEXT                  objectType,
6907     uint64_t                                    object,
6908     size_t                                      location,
6909     int32_t                                     messageCode,
6910     const char*                                 pLayerPrefix,
6911     const char*                                 pMessage,
6912     void*                                       pUserData);
6913 
6914 typedef struct VkDebugReportCallbackCreateInfoEXT {
6915     VkStructureType                 sType;
6916     const void*                     pNext;
6917     VkDebugReportFlagsEXT           flags;
6918     PFN_vkDebugReportCallbackEXT    pfnCallback;
6919     void*                           pUserData;
6920 } VkDebugReportCallbackCreateInfoEXT;
6921 
6922 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
6923 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
6924 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);
6925 
6926 #ifndef VK_NO_PROTOTYPES
6927 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
6928     VkInstance                                  instance,
6929     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
6930     const VkAllocationCallbacks*                pAllocator,
6931     VkDebugReportCallbackEXT*                   pCallback);
6932 
6933 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
6934     VkInstance                                  instance,
6935     VkDebugReportCallbackEXT                    callback,
6936     const VkAllocationCallbacks*                pAllocator);
6937 
6938 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
6939     VkInstance                                  instance,
6940     VkDebugReportFlagsEXT                       flags,
6941     VkDebugReportObjectTypeEXT                  objectType,
6942     uint64_t                                    object,
6943     size_t                                      location,
6944     int32_t                                     messageCode,
6945     const char*                                 pLayerPrefix,
6946     const char*                                 pMessage);
6947 #endif
6948 
6949 
6950 #define VK_NV_glsl_shader 1
6951 #define VK_NV_GLSL_SHADER_SPEC_VERSION    1
6952 #define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
6953 
6954 
6955 #define VK_EXT_depth_range_unrestricted 1
6956 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
6957 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
6958 
6959 
6960 #define VK_IMG_filter_cubic 1
6961 #define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
6962 #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
6963 
6964 
6965 #define VK_AMD_rasterization_order 1
6966 #define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
6967 #define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
6968 
6969 typedef enum VkRasterizationOrderAMD {
6970     VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
6971     VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
6972     VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
6973     VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
6974     VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
6975     VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
6976 } VkRasterizationOrderAMD;
6977 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
6978     VkStructureType            sType;
6979     const void*                pNext;
6980     VkRasterizationOrderAMD    rasterizationOrder;
6981 } VkPipelineRasterizationStateRasterizationOrderAMD;
6982 
6983 
6984 
6985 #define VK_AMD_shader_trinary_minmax 1
6986 #define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
6987 #define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
6988 
6989 
6990 #define VK_AMD_shader_explicit_vertex_parameter 1
6991 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
6992 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
6993 
6994 
6995 #define VK_EXT_debug_marker 1
6996 #define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
6997 #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
6998 typedef struct VkDebugMarkerObjectNameInfoEXT {
6999     VkStructureType               sType;
7000     const void*                   pNext;
7001     VkDebugReportObjectTypeEXT    objectType;
7002     uint64_t                      object;
7003     const char*                   pObjectName;
7004 } VkDebugMarkerObjectNameInfoEXT;
7005 
7006 typedef struct VkDebugMarkerObjectTagInfoEXT {
7007     VkStructureType               sType;
7008     const void*                   pNext;
7009     VkDebugReportObjectTypeEXT    objectType;
7010     uint64_t                      object;
7011     uint64_t                      tagName;
7012     size_t                        tagSize;
7013     const void*                   pTag;
7014 } VkDebugMarkerObjectTagInfoEXT;
7015 
7016 typedef struct VkDebugMarkerMarkerInfoEXT {
7017     VkStructureType    sType;
7018     const void*        pNext;
7019     const char*        pMarkerName;
7020     float              color[4];
7021 } VkDebugMarkerMarkerInfoEXT;
7022 
7023 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
7024 typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
7025 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
7026 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
7027 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
7028 
7029 #ifndef VK_NO_PROTOTYPES
7030 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
7031     VkDevice                                    device,
7032     const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
7033 
7034 VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
7035     VkDevice                                    device,
7036     const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
7037 
7038 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
7039     VkCommandBuffer                             commandBuffer,
7040     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
7041 
7042 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
7043     VkCommandBuffer                             commandBuffer);
7044 
7045 VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
7046     VkCommandBuffer                             commandBuffer,
7047     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
7048 #endif
7049 
7050 
7051 #define VK_AMD_gcn_shader 1
7052 #define VK_AMD_GCN_SHADER_SPEC_VERSION    1
7053 #define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
7054 
7055 
7056 #define VK_NV_dedicated_allocation 1
7057 #define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
7058 #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
7059 typedef struct VkDedicatedAllocationImageCreateInfoNV {
7060     VkStructureType    sType;
7061     const void*        pNext;
7062     VkBool32           dedicatedAllocation;
7063 } VkDedicatedAllocationImageCreateInfoNV;
7064 
7065 typedef struct VkDedicatedAllocationBufferCreateInfoNV {
7066     VkStructureType    sType;
7067     const void*        pNext;
7068     VkBool32           dedicatedAllocation;
7069 } VkDedicatedAllocationBufferCreateInfoNV;
7070 
7071 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
7072     VkStructureType    sType;
7073     const void*        pNext;
7074     VkImage            image;
7075     VkBuffer           buffer;
7076 } VkDedicatedAllocationMemoryAllocateInfoNV;
7077 
7078 
7079 
7080 #define VK_EXT_transform_feedback 1
7081 #define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1
7082 #define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback"
7083 typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT;
7084 typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
7085     VkStructureType    sType;
7086     void*              pNext;
7087     VkBool32           transformFeedback;
7088     VkBool32           geometryStreams;
7089 } VkPhysicalDeviceTransformFeedbackFeaturesEXT;
7090 
7091 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
7092     VkStructureType    sType;
7093     void*              pNext;
7094     uint32_t           maxTransformFeedbackStreams;
7095     uint32_t           maxTransformFeedbackBuffers;
7096     VkDeviceSize       maxTransformFeedbackBufferSize;
7097     uint32_t           maxTransformFeedbackStreamDataSize;
7098     uint32_t           maxTransformFeedbackBufferDataSize;
7099     uint32_t           maxTransformFeedbackBufferDataStride;
7100     VkBool32           transformFeedbackQueries;
7101     VkBool32           transformFeedbackStreamsLinesTriangles;
7102     VkBool32           transformFeedbackRasterizationStreamSelect;
7103     VkBool32           transformFeedbackDraw;
7104 } VkPhysicalDeviceTransformFeedbackPropertiesEXT;
7105 
7106 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT {
7107     VkStructureType                                     sType;
7108     const void*                                         pNext;
7109     VkPipelineRasterizationStateStreamCreateFlagsEXT    flags;
7110     uint32_t                                            rasterizationStream;
7111 } VkPipelineRasterizationStateStreamCreateInfoEXT;
7112 
7113 typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);
7114 typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
7115 typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
7116 typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index);
7117 typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
7118 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride);
7119 
7120 #ifndef VK_NO_PROTOTYPES
7121 VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(
7122     VkCommandBuffer                             commandBuffer,
7123     uint32_t                                    firstBinding,
7124     uint32_t                                    bindingCount,
7125     const VkBuffer*                             pBuffers,
7126     const VkDeviceSize*                         pOffsets,
7127     const VkDeviceSize*                         pSizes);
7128 
7129 VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(
7130     VkCommandBuffer                             commandBuffer,
7131     uint32_t                                    firstCounterBuffer,
7132     uint32_t                                    counterBufferCount,
7133     const VkBuffer*                             pCounterBuffers,
7134     const VkDeviceSize*                         pCounterBufferOffsets);
7135 
7136 VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(
7137     VkCommandBuffer                             commandBuffer,
7138     uint32_t                                    firstCounterBuffer,
7139     uint32_t                                    counterBufferCount,
7140     const VkBuffer*                             pCounterBuffers,
7141     const VkDeviceSize*                         pCounterBufferOffsets);
7142 
7143 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(
7144     VkCommandBuffer                             commandBuffer,
7145     VkQueryPool                                 queryPool,
7146     uint32_t                                    query,
7147     VkQueryControlFlags                         flags,
7148     uint32_t                                    index);
7149 
7150 VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(
7151     VkCommandBuffer                             commandBuffer,
7152     VkQueryPool                                 queryPool,
7153     uint32_t                                    query,
7154     uint32_t                                    index);
7155 
7156 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(
7157     VkCommandBuffer                             commandBuffer,
7158     uint32_t                                    instanceCount,
7159     uint32_t                                    firstInstance,
7160     VkBuffer                                    counterBuffer,
7161     VkDeviceSize                                counterBufferOffset,
7162     uint32_t                                    counterOffset,
7163     uint32_t                                    vertexStride);
7164 #endif
7165 
7166 
7167 #define VK_NVX_image_view_handle 1
7168 #define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 1
7169 #define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle"
7170 typedef struct VkImageViewHandleInfoNVX {
7171     VkStructureType     sType;
7172     const void*         pNext;
7173     VkImageView         imageView;
7174     VkDescriptorType    descriptorType;
7175     VkSampler           sampler;
7176 } VkImageViewHandleInfoNVX;
7177 
7178 typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
7179 
7180 #ifndef VK_NO_PROTOTYPES
7181 VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(
7182     VkDevice                                    device,
7183     const VkImageViewHandleInfoNVX*             pInfo);
7184 #endif
7185 
7186 
7187 #define VK_AMD_draw_indirect_count 1
7188 #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2
7189 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
7190 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
7191 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
7192 
7193 #ifndef VK_NO_PROTOTYPES
7194 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
7195     VkCommandBuffer                             commandBuffer,
7196     VkBuffer                                    buffer,
7197     VkDeviceSize                                offset,
7198     VkBuffer                                    countBuffer,
7199     VkDeviceSize                                countBufferOffset,
7200     uint32_t                                    maxDrawCount,
7201     uint32_t                                    stride);
7202 
7203 VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
7204     VkCommandBuffer                             commandBuffer,
7205     VkBuffer                                    buffer,
7206     VkDeviceSize                                offset,
7207     VkBuffer                                    countBuffer,
7208     VkDeviceSize                                countBufferOffset,
7209     uint32_t                                    maxDrawCount,
7210     uint32_t                                    stride);
7211 #endif
7212 
7213 
7214 #define VK_AMD_negative_viewport_height 1
7215 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
7216 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
7217 
7218 
7219 #define VK_AMD_gpu_shader_half_float 1
7220 #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2
7221 #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
7222 
7223 
7224 #define VK_AMD_shader_ballot 1
7225 #define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
7226 #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
7227 
7228 
7229 #define VK_AMD_texture_gather_bias_lod 1
7230 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
7231 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
7232 typedef struct VkTextureLODGatherFormatPropertiesAMD {
7233     VkStructureType    sType;
7234     void*              pNext;
7235     VkBool32           supportsTextureGatherLODBiasAMD;
7236 } VkTextureLODGatherFormatPropertiesAMD;
7237 
7238 
7239 
7240 #define VK_AMD_shader_info 1
7241 #define VK_AMD_SHADER_INFO_SPEC_VERSION   1
7242 #define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"
7243 
7244 typedef enum VkShaderInfoTypeAMD {
7245     VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,
7246     VK_SHADER_INFO_TYPE_BINARY_AMD = 1,
7247     VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
7248     VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
7249     VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD,
7250     VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1),
7251     VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF
7252 } VkShaderInfoTypeAMD;
7253 typedef struct VkShaderResourceUsageAMD {
7254     uint32_t    numUsedVgprs;
7255     uint32_t    numUsedSgprs;
7256     uint32_t    ldsSizePerLocalWorkGroup;
7257     size_t      ldsUsageSizeInBytes;
7258     size_t      scratchMemUsageInBytes;
7259 } VkShaderResourceUsageAMD;
7260 
7261 typedef struct VkShaderStatisticsInfoAMD {
7262     VkShaderStageFlags          shaderStageMask;
7263     VkShaderResourceUsageAMD    resourceUsage;
7264     uint32_t                    numPhysicalVgprs;
7265     uint32_t                    numPhysicalSgprs;
7266     uint32_t                    numAvailableVgprs;
7267     uint32_t                    numAvailableSgprs;
7268     uint32_t                    computeWorkGroupSize[3];
7269 } VkShaderStatisticsInfoAMD;
7270 
7271 typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);
7272 
7273 #ifndef VK_NO_PROTOTYPES
7274 VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(
7275     VkDevice                                    device,
7276     VkPipeline                                  pipeline,
7277     VkShaderStageFlagBits                       shaderStage,
7278     VkShaderInfoTypeAMD                         infoType,
7279     size_t*                                     pInfoSize,
7280     void*                                       pInfo);
7281 #endif
7282 
7283 
7284 #define VK_AMD_shader_image_load_store_lod 1
7285 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
7286 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"
7287 
7288 
7289 #define VK_NV_corner_sampled_image 1
7290 #define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2
7291 #define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"
7292 typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
7293     VkStructureType    sType;
7294     void*              pNext;
7295     VkBool32           cornerSampledImage;
7296 } VkPhysicalDeviceCornerSampledImageFeaturesNV;
7297 
7298 
7299 
7300 #define VK_IMG_format_pvrtc 1
7301 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
7302 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
7303 
7304 
7305 #define VK_NV_external_memory_capabilities 1
7306 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
7307 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
7308 
7309 typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
7310     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
7311     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
7312     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
7313     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
7314     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
7315 } VkExternalMemoryHandleTypeFlagBitsNV;
7316 typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
7317 
7318 typedef enum VkExternalMemoryFeatureFlagBitsNV {
7319     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
7320     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
7321     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
7322     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
7323 } VkExternalMemoryFeatureFlagBitsNV;
7324 typedef VkFlags VkExternalMemoryFeatureFlagsNV;
7325 typedef struct VkExternalImageFormatPropertiesNV {
7326     VkImageFormatProperties              imageFormatProperties;
7327     VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
7328     VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
7329     VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
7330 } VkExternalImageFormatPropertiesNV;
7331 
7332 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
7333 
7334 #ifndef VK_NO_PROTOTYPES
7335 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
7336     VkPhysicalDevice                            physicalDevice,
7337     VkFormat                                    format,
7338     VkImageType                                 type,
7339     VkImageTiling                               tiling,
7340     VkImageUsageFlags                           usage,
7341     VkImageCreateFlags                          flags,
7342     VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
7343     VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
7344 #endif
7345 
7346 
7347 #define VK_NV_external_memory 1
7348 #define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
7349 #define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
7350 typedef struct VkExternalMemoryImageCreateInfoNV {
7351     VkStructureType                      sType;
7352     const void*                          pNext;
7353     VkExternalMemoryHandleTypeFlagsNV    handleTypes;
7354 } VkExternalMemoryImageCreateInfoNV;
7355 
7356 typedef struct VkExportMemoryAllocateInfoNV {
7357     VkStructureType                      sType;
7358     const void*                          pNext;
7359     VkExternalMemoryHandleTypeFlagsNV    handleTypes;
7360 } VkExportMemoryAllocateInfoNV;
7361 
7362 
7363 
7364 #define VK_EXT_validation_flags 1
7365 #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2
7366 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
7367 
7368 typedef enum VkValidationCheckEXT {
7369     VK_VALIDATION_CHECK_ALL_EXT = 0,
7370     VK_VALIDATION_CHECK_SHADERS_EXT = 1,
7371     VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
7372     VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT,
7373     VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1),
7374     VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
7375 } VkValidationCheckEXT;
7376 typedef struct VkValidationFlagsEXT {
7377     VkStructureType                sType;
7378     const void*                    pNext;
7379     uint32_t                       disabledValidationCheckCount;
7380     const VkValidationCheckEXT*    pDisabledValidationChecks;
7381 } VkValidationFlagsEXT;
7382 
7383 
7384 
7385 #define VK_EXT_shader_subgroup_ballot 1
7386 #define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
7387 #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
7388 
7389 
7390 #define VK_EXT_shader_subgroup_vote 1
7391 #define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
7392 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
7393 
7394 
7395 #define VK_EXT_texture_compression_astc_hdr 1
7396 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1
7397 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
7398 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
7399     VkStructureType    sType;
7400     void*              pNext;
7401     VkBool32           textureCompressionASTC_HDR;
7402 } VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
7403 
7404 
7405 
7406 #define VK_EXT_astc_decode_mode 1
7407 #define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
7408 #define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"
7409 typedef struct VkImageViewASTCDecodeModeEXT {
7410     VkStructureType    sType;
7411     const void*        pNext;
7412     VkFormat           decodeMode;
7413 } VkImageViewASTCDecodeModeEXT;
7414 
7415 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
7416     VkStructureType    sType;
7417     void*              pNext;
7418     VkBool32           decodeModeSharedExponent;
7419 } VkPhysicalDeviceASTCDecodeFeaturesEXT;
7420 
7421 
7422 
7423 #define VK_EXT_conditional_rendering 1
7424 #define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2
7425 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
7426 
7427 typedef enum VkConditionalRenderingFlagBitsEXT {
7428     VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,
7429     VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
7430 } VkConditionalRenderingFlagBitsEXT;
7431 typedef VkFlags VkConditionalRenderingFlagsEXT;
7432 typedef struct VkConditionalRenderingBeginInfoEXT {
7433     VkStructureType                   sType;
7434     const void*                       pNext;
7435     VkBuffer                          buffer;
7436     VkDeviceSize                      offset;
7437     VkConditionalRenderingFlagsEXT    flags;
7438 } VkConditionalRenderingBeginInfoEXT;
7439 
7440 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
7441     VkStructureType    sType;
7442     void*              pNext;
7443     VkBool32           conditionalRendering;
7444     VkBool32           inheritedConditionalRendering;
7445 } VkPhysicalDeviceConditionalRenderingFeaturesEXT;
7446 
7447 typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
7448     VkStructureType    sType;
7449     const void*        pNext;
7450     VkBool32           conditionalRenderingEnable;
7451 } VkCommandBufferInheritanceConditionalRenderingInfoEXT;
7452 
7453 typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
7454 typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer);
7455 
7456 #ifndef VK_NO_PROTOTYPES
7457 VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(
7458     VkCommandBuffer                             commandBuffer,
7459     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
7460 
7461 VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(
7462     VkCommandBuffer                             commandBuffer);
7463 #endif
7464 
7465 
7466 #define VK_NVX_device_generated_commands 1
7467 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
7468 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
7469 #define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
7470 #define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
7471 
7472 typedef enum VkIndirectCommandsTokenTypeNVX {
7473     VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0,
7474     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1,
7475     VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2,
7476     VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3,
7477     VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4,
7478     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5,
7479     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6,
7480     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7,
7481     VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
7482     VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX,
7483     VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1),
7484     VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
7485 } VkIndirectCommandsTokenTypeNVX;
7486 
7487 typedef enum VkObjectEntryTypeNVX {
7488     VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0,
7489     VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1,
7490     VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2,
7491     VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3,
7492     VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4,
7493     VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
7494     VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX,
7495     VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1),
7496     VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
7497 } VkObjectEntryTypeNVX;
7498 
7499 typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
7500     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
7501     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
7502     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
7503     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
7504     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
7505 } VkIndirectCommandsLayoutUsageFlagBitsNVX;
7506 typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
7507 
7508 typedef enum VkObjectEntryUsageFlagBitsNVX {
7509     VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
7510     VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
7511     VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
7512 } VkObjectEntryUsageFlagBitsNVX;
7513 typedef VkFlags VkObjectEntryUsageFlagsNVX;
7514 typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
7515     VkStructureType    sType;
7516     const void*        pNext;
7517     VkBool32           computeBindingPointSupport;
7518 } VkDeviceGeneratedCommandsFeaturesNVX;
7519 
7520 typedef struct VkDeviceGeneratedCommandsLimitsNVX {
7521     VkStructureType    sType;
7522     const void*        pNext;
7523     uint32_t           maxIndirectCommandsLayoutTokenCount;
7524     uint32_t           maxObjectEntryCounts;
7525     uint32_t           minSequenceCountBufferOffsetAlignment;
7526     uint32_t           minSequenceIndexBufferOffsetAlignment;
7527     uint32_t           minCommandsTokenBufferOffsetAlignment;
7528 } VkDeviceGeneratedCommandsLimitsNVX;
7529 
7530 typedef struct VkIndirectCommandsTokenNVX {
7531     VkIndirectCommandsTokenTypeNVX    tokenType;
7532     VkBuffer                          buffer;
7533     VkDeviceSize                      offset;
7534 } VkIndirectCommandsTokenNVX;
7535 
7536 typedef struct VkIndirectCommandsLayoutTokenNVX {
7537     VkIndirectCommandsTokenTypeNVX    tokenType;
7538     uint32_t                          bindingUnit;
7539     uint32_t                          dynamicCount;
7540     uint32_t                          divisor;
7541 } VkIndirectCommandsLayoutTokenNVX;
7542 
7543 typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
7544     VkStructureType                            sType;
7545     const void*                                pNext;
7546     VkPipelineBindPoint                        pipelineBindPoint;
7547     VkIndirectCommandsLayoutUsageFlagsNVX      flags;
7548     uint32_t                                   tokenCount;
7549     const VkIndirectCommandsLayoutTokenNVX*    pTokens;
7550 } VkIndirectCommandsLayoutCreateInfoNVX;
7551 
7552 typedef struct VkCmdProcessCommandsInfoNVX {
7553     VkStructureType                      sType;
7554     const void*                          pNext;
7555     VkObjectTableNVX                     objectTable;
7556     VkIndirectCommandsLayoutNVX          indirectCommandsLayout;
7557     uint32_t                             indirectCommandsTokenCount;
7558     const VkIndirectCommandsTokenNVX*    pIndirectCommandsTokens;
7559     uint32_t                             maxSequencesCount;
7560     VkCommandBuffer                      targetCommandBuffer;
7561     VkBuffer                             sequencesCountBuffer;
7562     VkDeviceSize                         sequencesCountOffset;
7563     VkBuffer                             sequencesIndexBuffer;
7564     VkDeviceSize                         sequencesIndexOffset;
7565 } VkCmdProcessCommandsInfoNVX;
7566 
7567 typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
7568     VkStructureType                sType;
7569     const void*                    pNext;
7570     VkObjectTableNVX               objectTable;
7571     VkIndirectCommandsLayoutNVX    indirectCommandsLayout;
7572     uint32_t                       maxSequencesCount;
7573 } VkCmdReserveSpaceForCommandsInfoNVX;
7574 
7575 typedef struct VkObjectTableCreateInfoNVX {
7576     VkStructureType                      sType;
7577     const void*                          pNext;
7578     uint32_t                             objectCount;
7579     const VkObjectEntryTypeNVX*          pObjectEntryTypes;
7580     const uint32_t*                      pObjectEntryCounts;
7581     const VkObjectEntryUsageFlagsNVX*    pObjectEntryUsageFlags;
7582     uint32_t                             maxUniformBuffersPerDescriptor;
7583     uint32_t                             maxStorageBuffersPerDescriptor;
7584     uint32_t                             maxStorageImagesPerDescriptor;
7585     uint32_t                             maxSampledImagesPerDescriptor;
7586     uint32_t                             maxPipelineLayouts;
7587 } VkObjectTableCreateInfoNVX;
7588 
7589 typedef struct VkObjectTableEntryNVX {
7590     VkObjectEntryTypeNVX          type;
7591     VkObjectEntryUsageFlagsNVX    flags;
7592 } VkObjectTableEntryNVX;
7593 
7594 typedef struct VkObjectTablePipelineEntryNVX {
7595     VkObjectEntryTypeNVX          type;
7596     VkObjectEntryUsageFlagsNVX    flags;
7597     VkPipeline                    pipeline;
7598 } VkObjectTablePipelineEntryNVX;
7599 
7600 typedef struct VkObjectTableDescriptorSetEntryNVX {
7601     VkObjectEntryTypeNVX          type;
7602     VkObjectEntryUsageFlagsNVX    flags;
7603     VkPipelineLayout              pipelineLayout;
7604     VkDescriptorSet               descriptorSet;
7605 } VkObjectTableDescriptorSetEntryNVX;
7606 
7607 typedef struct VkObjectTableVertexBufferEntryNVX {
7608     VkObjectEntryTypeNVX          type;
7609     VkObjectEntryUsageFlagsNVX    flags;
7610     VkBuffer                      buffer;
7611 } VkObjectTableVertexBufferEntryNVX;
7612 
7613 typedef struct VkObjectTableIndexBufferEntryNVX {
7614     VkObjectEntryTypeNVX          type;
7615     VkObjectEntryUsageFlagsNVX    flags;
7616     VkBuffer                      buffer;
7617     VkIndexType                   indexType;
7618 } VkObjectTableIndexBufferEntryNVX;
7619 
7620 typedef struct VkObjectTablePushConstantEntryNVX {
7621     VkObjectEntryTypeNVX          type;
7622     VkObjectEntryUsageFlagsNVX    flags;
7623     VkPipelineLayout              pipelineLayout;
7624     VkShaderStageFlags            stageFlags;
7625 } VkObjectTablePushConstantEntryNVX;
7626 
7627 typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
7628 typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
7629 typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
7630 typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
7631 typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
7632 typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
7633 typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const*    ppObjectTableEntries, const uint32_t* pObjectIndices);
7634 typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices);
7635 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
7636 
7637 #ifndef VK_NO_PROTOTYPES
7638 VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
7639     VkCommandBuffer                             commandBuffer,
7640     const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
7641 
7642 VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
7643     VkCommandBuffer                             commandBuffer,
7644     const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
7645 
7646 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
7647     VkDevice                                    device,
7648     const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
7649     const VkAllocationCallbacks*                pAllocator,
7650     VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
7651 
7652 VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
7653     VkDevice                                    device,
7654     VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
7655     const VkAllocationCallbacks*                pAllocator);
7656 
7657 VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
7658     VkDevice                                    device,
7659     const VkObjectTableCreateInfoNVX*           pCreateInfo,
7660     const VkAllocationCallbacks*                pAllocator,
7661     VkObjectTableNVX*                           pObjectTable);
7662 
7663 VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(
7664     VkDevice                                    device,
7665     VkObjectTableNVX                            objectTable,
7666     const VkAllocationCallbacks*                pAllocator);
7667 
7668 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
7669     VkDevice                                    device,
7670     VkObjectTableNVX                            objectTable,
7671     uint32_t                                    objectCount,
7672     const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
7673     const uint32_t*                             pObjectIndices);
7674 
7675 VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
7676     VkDevice                                    device,
7677     VkObjectTableNVX                            objectTable,
7678     uint32_t                                    objectCount,
7679     const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
7680     const uint32_t*                             pObjectIndices);
7681 
7682 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
7683     VkPhysicalDevice                            physicalDevice,
7684     VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
7685     VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
7686 #endif
7687 
7688 
7689 #define VK_NV_clip_space_w_scaling 1
7690 #define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
7691 #define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
7692 typedef struct VkViewportWScalingNV {
7693     float    xcoeff;
7694     float    ycoeff;
7695 } VkViewportWScalingNV;
7696 
7697 typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
7698     VkStructureType                sType;
7699     const void*                    pNext;
7700     VkBool32                       viewportWScalingEnable;
7701     uint32_t                       viewportCount;
7702     const VkViewportWScalingNV*    pViewportWScalings;
7703 } VkPipelineViewportWScalingStateCreateInfoNV;
7704 
7705 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
7706 
7707 #ifndef VK_NO_PROTOTYPES
7708 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
7709     VkCommandBuffer                             commandBuffer,
7710     uint32_t                                    firstViewport,
7711     uint32_t                                    viewportCount,
7712     const VkViewportWScalingNV*                 pViewportWScalings);
7713 #endif
7714 
7715 
7716 #define VK_EXT_direct_mode_display 1
7717 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
7718 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
7719 typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
7720 
7721 #ifndef VK_NO_PROTOTYPES
7722 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
7723     VkPhysicalDevice                            physicalDevice,
7724     VkDisplayKHR                                display);
7725 #endif
7726 
7727 
7728 #define VK_EXT_display_surface_counter 1
7729 #define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
7730 #define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
7731 
7732 typedef enum VkSurfaceCounterFlagBitsEXT {
7733     VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001,
7734     VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
7735 } VkSurfaceCounterFlagBitsEXT;
7736 typedef VkFlags VkSurfaceCounterFlagsEXT;
7737 typedef struct VkSurfaceCapabilities2EXT {
7738     VkStructureType                  sType;
7739     void*                            pNext;
7740     uint32_t                         minImageCount;
7741     uint32_t                         maxImageCount;
7742     VkExtent2D                       currentExtent;
7743     VkExtent2D                       minImageExtent;
7744     VkExtent2D                       maxImageExtent;
7745     uint32_t                         maxImageArrayLayers;
7746     VkSurfaceTransformFlagsKHR       supportedTransforms;
7747     VkSurfaceTransformFlagBitsKHR    currentTransform;
7748     VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
7749     VkImageUsageFlags                supportedUsageFlags;
7750     VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
7751 } VkSurfaceCapabilities2EXT;
7752 
7753 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
7754 
7755 #ifndef VK_NO_PROTOTYPES
7756 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
7757     VkPhysicalDevice                            physicalDevice,
7758     VkSurfaceKHR                                surface,
7759     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
7760 #endif
7761 
7762 
7763 #define VK_EXT_display_control 1
7764 #define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
7765 #define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
7766 
7767 typedef enum VkDisplayPowerStateEXT {
7768     VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
7769     VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
7770     VK_DISPLAY_POWER_STATE_ON_EXT = 2,
7771     VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT,
7772     VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT,
7773     VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1),
7774     VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
7775 } VkDisplayPowerStateEXT;
7776 
7777 typedef enum VkDeviceEventTypeEXT {
7778     VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
7779     VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
7780     VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
7781     VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1),
7782     VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
7783 } VkDeviceEventTypeEXT;
7784 
7785 typedef enum VkDisplayEventTypeEXT {
7786     VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
7787     VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
7788     VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
7789     VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1),
7790     VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
7791 } VkDisplayEventTypeEXT;
7792 typedef struct VkDisplayPowerInfoEXT {
7793     VkStructureType           sType;
7794     const void*               pNext;
7795     VkDisplayPowerStateEXT    powerState;
7796 } VkDisplayPowerInfoEXT;
7797 
7798 typedef struct VkDeviceEventInfoEXT {
7799     VkStructureType         sType;
7800     const void*             pNext;
7801     VkDeviceEventTypeEXT    deviceEvent;
7802 } VkDeviceEventInfoEXT;
7803 
7804 typedef struct VkDisplayEventInfoEXT {
7805     VkStructureType          sType;
7806     const void*              pNext;
7807     VkDisplayEventTypeEXT    displayEvent;
7808 } VkDisplayEventInfoEXT;
7809 
7810 typedef struct VkSwapchainCounterCreateInfoEXT {
7811     VkStructureType             sType;
7812     const void*                 pNext;
7813     VkSurfaceCounterFlagsEXT    surfaceCounters;
7814 } VkSwapchainCounterCreateInfoEXT;
7815 
7816 typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
7817 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
7818 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
7819 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
7820 
7821 #ifndef VK_NO_PROTOTYPES
7822 VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
7823     VkDevice                                    device,
7824     VkDisplayKHR                                display,
7825     const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
7826 
7827 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
7828     VkDevice                                    device,
7829     const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
7830     const VkAllocationCallbacks*                pAllocator,
7831     VkFence*                                    pFence);
7832 
7833 VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
7834     VkDevice                                    device,
7835     VkDisplayKHR                                display,
7836     const VkDisplayEventInfoEXT*                pDisplayEventInfo,
7837     const VkAllocationCallbacks*                pAllocator,
7838     VkFence*                                    pFence);
7839 
7840 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
7841     VkDevice                                    device,
7842     VkSwapchainKHR                              swapchain,
7843     VkSurfaceCounterFlagBitsEXT                 counter,
7844     uint64_t*                                   pCounterValue);
7845 #endif
7846 
7847 
7848 #define VK_GOOGLE_display_timing 1
7849 #define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
7850 #define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
7851 typedef struct VkRefreshCycleDurationGOOGLE {
7852     uint64_t    refreshDuration;
7853 } VkRefreshCycleDurationGOOGLE;
7854 
7855 typedef struct VkPastPresentationTimingGOOGLE {
7856     uint32_t    presentID;
7857     uint64_t    desiredPresentTime;
7858     uint64_t    actualPresentTime;
7859     uint64_t    earliestPresentTime;
7860     uint64_t    presentMargin;
7861 } VkPastPresentationTimingGOOGLE;
7862 
7863 typedef struct VkPresentTimeGOOGLE {
7864     uint32_t    presentID;
7865     uint64_t    desiredPresentTime;
7866 } VkPresentTimeGOOGLE;
7867 
7868 typedef struct VkPresentTimesInfoGOOGLE {
7869     VkStructureType               sType;
7870     const void*                   pNext;
7871     uint32_t                      swapchainCount;
7872     const VkPresentTimeGOOGLE*    pTimes;
7873 } VkPresentTimesInfoGOOGLE;
7874 
7875 typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
7876 typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
7877 
7878 #ifndef VK_NO_PROTOTYPES
7879 VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
7880     VkDevice                                    device,
7881     VkSwapchainKHR                              swapchain,
7882     VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
7883 
7884 VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
7885     VkDevice                                    device,
7886     VkSwapchainKHR                              swapchain,
7887     uint32_t*                                   pPresentationTimingCount,
7888     VkPastPresentationTimingGOOGLE*             pPresentationTimings);
7889 #endif
7890 
7891 
7892 #define VK_NV_sample_mask_override_coverage 1
7893 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
7894 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
7895 
7896 
7897 #define VK_NV_geometry_shader_passthrough 1
7898 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
7899 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
7900 
7901 
7902 #define VK_NV_viewport_array2 1
7903 #define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
7904 #define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
7905 
7906 
7907 #define VK_NVX_multiview_per_view_attributes 1
7908 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
7909 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
7910 typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
7911     VkStructureType    sType;
7912     void*              pNext;
7913     VkBool32           perViewPositionAllComponents;
7914 } VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
7915 
7916 
7917 
7918 #define VK_NV_viewport_swizzle 1
7919 #define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
7920 #define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
7921 
7922 typedef enum VkViewportCoordinateSwizzleNV {
7923     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
7924     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
7925     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
7926     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
7927     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
7928     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
7929     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
7930     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
7931     VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
7932     VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV,
7933     VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1),
7934     VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
7935 } VkViewportCoordinateSwizzleNV;
7936 typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
7937 typedef struct VkViewportSwizzleNV {
7938     VkViewportCoordinateSwizzleNV    x;
7939     VkViewportCoordinateSwizzleNV    y;
7940     VkViewportCoordinateSwizzleNV    z;
7941     VkViewportCoordinateSwizzleNV    w;
7942 } VkViewportSwizzleNV;
7943 
7944 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
7945     VkStructureType                                sType;
7946     const void*                                    pNext;
7947     VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
7948     uint32_t                                       viewportCount;
7949     const VkViewportSwizzleNV*                     pViewportSwizzles;
7950 } VkPipelineViewportSwizzleStateCreateInfoNV;
7951 
7952 
7953 
7954 #define VK_EXT_discard_rectangles 1
7955 #define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
7956 #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
7957 
7958 typedef enum VkDiscardRectangleModeEXT {
7959     VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
7960     VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
7961     VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
7962     VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT,
7963     VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1),
7964     VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
7965 } VkDiscardRectangleModeEXT;
7966 typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
7967 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
7968     VkStructureType    sType;
7969     void*              pNext;
7970     uint32_t           maxDiscardRectangles;
7971 } VkPhysicalDeviceDiscardRectanglePropertiesEXT;
7972 
7973 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
7974     VkStructureType                                  sType;
7975     const void*                                      pNext;
7976     VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
7977     VkDiscardRectangleModeEXT                        discardRectangleMode;
7978     uint32_t                                         discardRectangleCount;
7979     const VkRect2D*                                  pDiscardRectangles;
7980 } VkPipelineDiscardRectangleStateCreateInfoEXT;
7981 
7982 typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
7983 
7984 #ifndef VK_NO_PROTOTYPES
7985 VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
7986     VkCommandBuffer                             commandBuffer,
7987     uint32_t                                    firstDiscardRectangle,
7988     uint32_t                                    discardRectangleCount,
7989     const VkRect2D*                             pDiscardRectangles);
7990 #endif
7991 
7992 
7993 #define VK_EXT_conservative_rasterization 1
7994 #define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
7995 #define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"
7996 
7997 typedef enum VkConservativeRasterizationModeEXT {
7998     VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,
7999     VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,
8000     VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,
8001     VK_CONSERVATIVE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
8002     VK_CONSERVATIVE_RASTERIZATION_MODE_END_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT,
8003     VK_CONSERVATIVE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + 1),
8004     VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
8005 } VkConservativeRasterizationModeEXT;
8006 typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;
8007 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
8008     VkStructureType    sType;
8009     void*              pNext;
8010     float              primitiveOverestimationSize;
8011     float              maxExtraPrimitiveOverestimationSize;
8012     float              extraPrimitiveOverestimationSizeGranularity;
8013     VkBool32           primitiveUnderestimation;
8014     VkBool32           conservativePointAndLineRasterization;
8015     VkBool32           degenerateTrianglesRasterized;
8016     VkBool32           degenerateLinesRasterized;
8017     VkBool32           fullyCoveredFragmentShaderInputVariable;
8018     VkBool32           conservativeRasterizationPostDepthCoverage;
8019 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
8020 
8021 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
8022     VkStructureType                                           sType;
8023     const void*                                               pNext;
8024     VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags;
8025     VkConservativeRasterizationModeEXT                        conservativeRasterizationMode;
8026     float                                                     extraPrimitiveOverestimationSize;
8027 } VkPipelineRasterizationConservativeStateCreateInfoEXT;
8028 
8029 
8030 
8031 #define VK_EXT_depth_clip_enable 1
8032 #define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1
8033 #define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable"
8034 typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT;
8035 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
8036     VkStructureType    sType;
8037     void*              pNext;
8038     VkBool32           depthClipEnable;
8039 } VkPhysicalDeviceDepthClipEnableFeaturesEXT;
8040 
8041 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
8042     VkStructureType                                        sType;
8043     const void*                                            pNext;
8044     VkPipelineRasterizationDepthClipStateCreateFlagsEXT    flags;
8045     VkBool32                                               depthClipEnable;
8046 } VkPipelineRasterizationDepthClipStateCreateInfoEXT;
8047 
8048 
8049 
8050 #define VK_EXT_swapchain_colorspace 1
8051 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4
8052 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
8053 
8054 
8055 #define VK_EXT_hdr_metadata 1
8056 #define VK_EXT_HDR_METADATA_SPEC_VERSION  2
8057 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
8058 typedef struct VkXYColorEXT {
8059     float    x;
8060     float    y;
8061 } VkXYColorEXT;
8062 
8063 typedef struct VkHdrMetadataEXT {
8064     VkStructureType    sType;
8065     const void*        pNext;
8066     VkXYColorEXT       displayPrimaryRed;
8067     VkXYColorEXT       displayPrimaryGreen;
8068     VkXYColorEXT       displayPrimaryBlue;
8069     VkXYColorEXT       whitePoint;
8070     float              maxLuminance;
8071     float              minLuminance;
8072     float              maxContentLightLevel;
8073     float              maxFrameAverageLightLevel;
8074 } VkHdrMetadataEXT;
8075 
8076 typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
8077 
8078 #ifndef VK_NO_PROTOTYPES
8079 VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
8080     VkDevice                                    device,
8081     uint32_t                                    swapchainCount,
8082     const VkSwapchainKHR*                       pSwapchains,
8083     const VkHdrMetadataEXT*                     pMetadata);
8084 #endif
8085 
8086 
8087 #define VK_EXT_external_memory_dma_buf 1
8088 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
8089 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"
8090 
8091 
8092 #define VK_EXT_queue_family_foreign 1
8093 #define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
8094 #define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"
8095 #define VK_QUEUE_FAMILY_FOREIGN_EXT       (~0U-2)
8096 
8097 
8098 #define VK_EXT_debug_utils 1
8099 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)
8100 #define VK_EXT_DEBUG_UTILS_SPEC_VERSION   1
8101 #define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"
8102 typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT;
8103 typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT;
8104 
8105 typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT {
8106     VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,
8107     VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010,
8108     VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,
8109     VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000,
8110     VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
8111 } VkDebugUtilsMessageSeverityFlagBitsEXT;
8112 typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;
8113 
8114 typedef enum VkDebugUtilsMessageTypeFlagBitsEXT {
8115     VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001,
8116     VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002,
8117     VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
8118     VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
8119 } VkDebugUtilsMessageTypeFlagBitsEXT;
8120 typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;
8121 typedef struct VkDebugUtilsObjectNameInfoEXT {
8122     VkStructureType    sType;
8123     const void*        pNext;
8124     VkObjectType       objectType;
8125     uint64_t           objectHandle;
8126     const char*        pObjectName;
8127 } VkDebugUtilsObjectNameInfoEXT;
8128 
8129 typedef struct VkDebugUtilsObjectTagInfoEXT {
8130     VkStructureType    sType;
8131     const void*        pNext;
8132     VkObjectType       objectType;
8133     uint64_t           objectHandle;
8134     uint64_t           tagName;
8135     size_t             tagSize;
8136     const void*        pTag;
8137 } VkDebugUtilsObjectTagInfoEXT;
8138 
8139 typedef struct VkDebugUtilsLabelEXT {
8140     VkStructureType    sType;
8141     const void*        pNext;
8142     const char*        pLabelName;
8143     float              color[4];
8144 } VkDebugUtilsLabelEXT;
8145 
8146 typedef struct VkDebugUtilsMessengerCallbackDataEXT {
8147     VkStructureType                              sType;
8148     const void*                                  pNext;
8149     VkDebugUtilsMessengerCallbackDataFlagsEXT    flags;
8150     const char*                                  pMessageIdName;
8151     int32_t                                      messageIdNumber;
8152     const char*                                  pMessage;
8153     uint32_t                                     queueLabelCount;
8154     const VkDebugUtilsLabelEXT*                  pQueueLabels;
8155     uint32_t                                     cmdBufLabelCount;
8156     const VkDebugUtilsLabelEXT*                  pCmdBufLabels;
8157     uint32_t                                     objectCount;
8158     const VkDebugUtilsObjectNameInfoEXT*         pObjects;
8159 } VkDebugUtilsMessengerCallbackDataEXT;
8160 
8161 typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(
8162     VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
8163     VkDebugUtilsMessageTypeFlagsEXT                  messageTypes,
8164     const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
8165     void*                                            pUserData);
8166 
8167 typedef struct VkDebugUtilsMessengerCreateInfoEXT {
8168     VkStructureType                         sType;
8169     const void*                             pNext;
8170     VkDebugUtilsMessengerCreateFlagsEXT     flags;
8171     VkDebugUtilsMessageSeverityFlagsEXT     messageSeverity;
8172     VkDebugUtilsMessageTypeFlagsEXT         messageType;
8173     PFN_vkDebugUtilsMessengerCallbackEXT    pfnUserCallback;
8174     void*                                   pUserData;
8175 } VkDebugUtilsMessengerCreateInfoEXT;
8176 
8177 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
8178 typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
8179 typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
8180 typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue);
8181 typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
8182 typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
8183 typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer);
8184 typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
8185 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
8186 typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
8187 typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
8188 
8189 #ifndef VK_NO_PROTOTYPES
8190 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(
8191     VkDevice                                    device,
8192     const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);
8193 
8194 VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(
8195     VkDevice                                    device,
8196     const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);
8197 
8198 VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(
8199     VkQueue                                     queue,
8200     const VkDebugUtilsLabelEXT*                 pLabelInfo);
8201 
8202 VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(
8203     VkQueue                                     queue);
8204 
8205 VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(
8206     VkQueue                                     queue,
8207     const VkDebugUtilsLabelEXT*                 pLabelInfo);
8208 
8209 VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(
8210     VkCommandBuffer                             commandBuffer,
8211     const VkDebugUtilsLabelEXT*                 pLabelInfo);
8212 
8213 VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(
8214     VkCommandBuffer                             commandBuffer);
8215 
8216 VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(
8217     VkCommandBuffer                             commandBuffer,
8218     const VkDebugUtilsLabelEXT*                 pLabelInfo);
8219 
8220 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(
8221     VkInstance                                  instance,
8222     const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
8223     const VkAllocationCallbacks*                pAllocator,
8224     VkDebugUtilsMessengerEXT*                   pMessenger);
8225 
8226 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(
8227     VkInstance                                  instance,
8228     VkDebugUtilsMessengerEXT                    messenger,
8229     const VkAllocationCallbacks*                pAllocator);
8230 
8231 VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(
8232     VkInstance                                  instance,
8233     VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
8234     VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
8235     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
8236 #endif
8237 
8238 
8239 #define VK_EXT_sampler_filter_minmax 1
8240 #define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2
8241 #define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
8242 
8243 typedef enum VkSamplerReductionModeEXT {
8244     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0,
8245     VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1,
8246     VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2,
8247     VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
8248     VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT,
8249     VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1),
8250     VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
8251 } VkSamplerReductionModeEXT;
8252 typedef struct VkSamplerReductionModeCreateInfoEXT {
8253     VkStructureType              sType;
8254     const void*                  pNext;
8255     VkSamplerReductionModeEXT    reductionMode;
8256 } VkSamplerReductionModeCreateInfoEXT;
8257 
8258 typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
8259     VkStructureType    sType;
8260     void*              pNext;
8261     VkBool32           filterMinmaxSingleComponentFormats;
8262     VkBool32           filterMinmaxImageComponentMapping;
8263 } VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
8264 
8265 
8266 
8267 #define VK_AMD_gpu_shader_int16 1
8268 #define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2
8269 #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
8270 
8271 
8272 #define VK_AMD_mixed_attachment_samples 1
8273 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
8274 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
8275 
8276 
8277 #define VK_AMD_shader_fragment_mask 1
8278 #define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
8279 #define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"
8280 
8281 
8282 #define VK_EXT_inline_uniform_block 1
8283 #define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1
8284 #define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block"
8285 typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT {
8286     VkStructureType    sType;
8287     void*              pNext;
8288     VkBool32           inlineUniformBlock;
8289     VkBool32           descriptorBindingInlineUniformBlockUpdateAfterBind;
8290 } VkPhysicalDeviceInlineUniformBlockFeaturesEXT;
8291 
8292 typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT {
8293     VkStructureType    sType;
8294     void*              pNext;
8295     uint32_t           maxInlineUniformBlockSize;
8296     uint32_t           maxPerStageDescriptorInlineUniformBlocks;
8297     uint32_t           maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
8298     uint32_t           maxDescriptorSetInlineUniformBlocks;
8299     uint32_t           maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
8300 } VkPhysicalDeviceInlineUniformBlockPropertiesEXT;
8301 
8302 typedef struct VkWriteDescriptorSetInlineUniformBlockEXT {
8303     VkStructureType    sType;
8304     const void*        pNext;
8305     uint32_t           dataSize;
8306     const void*        pData;
8307 } VkWriteDescriptorSetInlineUniformBlockEXT;
8308 
8309 typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT {
8310     VkStructureType    sType;
8311     const void*        pNext;
8312     uint32_t           maxInlineUniformBlockBindings;
8313 } VkDescriptorPoolInlineUniformBlockCreateInfoEXT;
8314 
8315 
8316 
8317 #define VK_EXT_shader_stencil_export 1
8318 #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
8319 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
8320 
8321 
8322 #define VK_EXT_sample_locations 1
8323 #define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
8324 #define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"
8325 typedef struct VkSampleLocationEXT {
8326     float    x;
8327     float    y;
8328 } VkSampleLocationEXT;
8329 
8330 typedef struct VkSampleLocationsInfoEXT {
8331     VkStructureType               sType;
8332     const void*                   pNext;
8333     VkSampleCountFlagBits         sampleLocationsPerPixel;
8334     VkExtent2D                    sampleLocationGridSize;
8335     uint32_t                      sampleLocationsCount;
8336     const VkSampleLocationEXT*    pSampleLocations;
8337 } VkSampleLocationsInfoEXT;
8338 
8339 typedef struct VkAttachmentSampleLocationsEXT {
8340     uint32_t                    attachmentIndex;
8341     VkSampleLocationsInfoEXT    sampleLocationsInfo;
8342 } VkAttachmentSampleLocationsEXT;
8343 
8344 typedef struct VkSubpassSampleLocationsEXT {
8345     uint32_t                    subpassIndex;
8346     VkSampleLocationsInfoEXT    sampleLocationsInfo;
8347 } VkSubpassSampleLocationsEXT;
8348 
8349 typedef struct VkRenderPassSampleLocationsBeginInfoEXT {
8350     VkStructureType                          sType;
8351     const void*                              pNext;
8352     uint32_t                                 attachmentInitialSampleLocationsCount;
8353     const VkAttachmentSampleLocationsEXT*    pAttachmentInitialSampleLocations;
8354     uint32_t                                 postSubpassSampleLocationsCount;
8355     const VkSubpassSampleLocationsEXT*       pPostSubpassSampleLocations;
8356 } VkRenderPassSampleLocationsBeginInfoEXT;
8357 
8358 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {
8359     VkStructureType             sType;
8360     const void*                 pNext;
8361     VkBool32                    sampleLocationsEnable;
8362     VkSampleLocationsInfoEXT    sampleLocationsInfo;
8363 } VkPipelineSampleLocationsStateCreateInfoEXT;
8364 
8365 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
8366     VkStructureType       sType;
8367     void*                 pNext;
8368     VkSampleCountFlags    sampleLocationSampleCounts;
8369     VkExtent2D            maxSampleLocationGridSize;
8370     float                 sampleLocationCoordinateRange[2];
8371     uint32_t              sampleLocationSubPixelBits;
8372     VkBool32              variableSampleLocations;
8373 } VkPhysicalDeviceSampleLocationsPropertiesEXT;
8374 
8375 typedef struct VkMultisamplePropertiesEXT {
8376     VkStructureType    sType;
8377     void*              pNext;
8378     VkExtent2D         maxSampleLocationGridSize;
8379 } VkMultisamplePropertiesEXT;
8380 
8381 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
8382 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);
8383 
8384 #ifndef VK_NO_PROTOTYPES
8385 VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(
8386     VkCommandBuffer                             commandBuffer,
8387     const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
8388 
8389 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(
8390     VkPhysicalDevice                            physicalDevice,
8391     VkSampleCountFlagBits                       samples,
8392     VkMultisamplePropertiesEXT*                 pMultisampleProperties);
8393 #endif
8394 
8395 
8396 #define VK_EXT_blend_operation_advanced 1
8397 #define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
8398 #define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
8399 
8400 typedef enum VkBlendOverlapEXT {
8401     VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
8402     VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
8403     VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
8404     VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
8405     VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT,
8406     VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1),
8407     VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
8408 } VkBlendOverlapEXT;
8409 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
8410     VkStructureType    sType;
8411     void*              pNext;
8412     VkBool32           advancedBlendCoherentOperations;
8413 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
8414 
8415 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
8416     VkStructureType    sType;
8417     void*              pNext;
8418     uint32_t           advancedBlendMaxColorAttachments;
8419     VkBool32           advancedBlendIndependentBlend;
8420     VkBool32           advancedBlendNonPremultipliedSrcColor;
8421     VkBool32           advancedBlendNonPremultipliedDstColor;
8422     VkBool32           advancedBlendCorrelatedOverlap;
8423     VkBool32           advancedBlendAllOperations;
8424 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
8425 
8426 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
8427     VkStructureType      sType;
8428     const void*          pNext;
8429     VkBool32             srcPremultiplied;
8430     VkBool32             dstPremultiplied;
8431     VkBlendOverlapEXT    blendOverlap;
8432 } VkPipelineColorBlendAdvancedStateCreateInfoEXT;
8433 
8434 
8435 
8436 #define VK_NV_fragment_coverage_to_color 1
8437 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
8438 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
8439 typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
8440 typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
8441     VkStructureType                                sType;
8442     const void*                                    pNext;
8443     VkPipelineCoverageToColorStateCreateFlagsNV    flags;
8444     VkBool32                                       coverageToColorEnable;
8445     uint32_t                                       coverageToColorLocation;
8446 } VkPipelineCoverageToColorStateCreateInfoNV;
8447 
8448 
8449 
8450 #define VK_NV_framebuffer_mixed_samples 1
8451 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
8452 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
8453 
8454 typedef enum VkCoverageModulationModeNV {
8455     VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
8456     VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
8457     VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
8458     VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
8459     VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV,
8460     VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV,
8461     VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1),
8462     VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
8463 } VkCoverageModulationModeNV;
8464 typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
8465 typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
8466     VkStructureType                                   sType;
8467     const void*                                       pNext;
8468     VkPipelineCoverageModulationStateCreateFlagsNV    flags;
8469     VkCoverageModulationModeNV                        coverageModulationMode;
8470     VkBool32                                          coverageModulationTableEnable;
8471     uint32_t                                          coverageModulationTableCount;
8472     const float*                                      pCoverageModulationTable;
8473 } VkPipelineCoverageModulationStateCreateInfoNV;
8474 
8475 
8476 
8477 #define VK_NV_fill_rectangle 1
8478 #define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
8479 #define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
8480 
8481 
8482 #define VK_NV_shader_sm_builtins 1
8483 #define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1
8484 #define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins"
8485 typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
8486     VkStructureType    sType;
8487     void*              pNext;
8488     uint32_t           shaderSMCount;
8489     uint32_t           shaderWarpsPerSM;
8490 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;
8491 
8492 typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
8493     VkStructureType    sType;
8494     void*              pNext;
8495     VkBool32           shaderSMBuiltins;
8496 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
8497 
8498 
8499 
8500 #define VK_EXT_post_depth_coverage 1
8501 #define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
8502 #define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
8503 
8504 
8505 #define VK_EXT_image_drm_format_modifier 1
8506 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1
8507 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier"
8508 typedef struct VkDrmFormatModifierPropertiesEXT {
8509     uint64_t                drmFormatModifier;
8510     uint32_t                drmFormatModifierPlaneCount;
8511     VkFormatFeatureFlags    drmFormatModifierTilingFeatures;
8512 } VkDrmFormatModifierPropertiesEXT;
8513 
8514 typedef struct VkDrmFormatModifierPropertiesListEXT {
8515     VkStructureType                      sType;
8516     void*                                pNext;
8517     uint32_t                             drmFormatModifierCount;
8518     VkDrmFormatModifierPropertiesEXT*    pDrmFormatModifierProperties;
8519 } VkDrmFormatModifierPropertiesListEXT;
8520 
8521 typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
8522     VkStructureType    sType;
8523     const void*        pNext;
8524     uint64_t           drmFormatModifier;
8525     VkSharingMode      sharingMode;
8526     uint32_t           queueFamilyIndexCount;
8527     const uint32_t*    pQueueFamilyIndices;
8528 } VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
8529 
8530 typedef struct VkImageDrmFormatModifierListCreateInfoEXT {
8531     VkStructureType    sType;
8532     const void*        pNext;
8533     uint32_t           drmFormatModifierCount;
8534     const uint64_t*    pDrmFormatModifiers;
8535 } VkImageDrmFormatModifierListCreateInfoEXT;
8536 
8537 typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
8538     VkStructureType               sType;
8539     const void*                   pNext;
8540     uint64_t                      drmFormatModifier;
8541     uint32_t                      drmFormatModifierPlaneCount;
8542     const VkSubresourceLayout*    pPlaneLayouts;
8543 } VkImageDrmFormatModifierExplicitCreateInfoEXT;
8544 
8545 typedef struct VkImageDrmFormatModifierPropertiesEXT {
8546     VkStructureType    sType;
8547     void*              pNext;
8548     uint64_t           drmFormatModifier;
8549 } VkImageDrmFormatModifierPropertiesEXT;
8550 
8551 typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties);
8552 
8553 #ifndef VK_NO_PROTOTYPES
8554 VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(
8555     VkDevice                                    device,
8556     VkImage                                     image,
8557     VkImageDrmFormatModifierPropertiesEXT*      pProperties);
8558 #endif
8559 
8560 
8561 #define VK_EXT_validation_cache 1
8562 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
8563 #define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
8564 #define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"
8565 
8566 typedef enum VkValidationCacheHeaderVersionEXT {
8567     VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,
8568     VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT,
8569     VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT,
8570     VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1),
8571     VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF
8572 } VkValidationCacheHeaderVersionEXT;
8573 typedef VkFlags VkValidationCacheCreateFlagsEXT;
8574 typedef struct VkValidationCacheCreateInfoEXT {
8575     VkStructureType                    sType;
8576     const void*                        pNext;
8577     VkValidationCacheCreateFlagsEXT    flags;
8578     size_t                             initialDataSize;
8579     const void*                        pInitialData;
8580 } VkValidationCacheCreateInfoEXT;
8581 
8582 typedef struct VkShaderModuleValidationCacheCreateInfoEXT {
8583     VkStructureType         sType;
8584     const void*             pNext;
8585     VkValidationCacheEXT    validationCache;
8586 } VkShaderModuleValidationCacheCreateInfoEXT;
8587 
8588 typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);
8589 typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);
8590 typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);
8591 typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);
8592 
8593 #ifndef VK_NO_PROTOTYPES
8594 VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(
8595     VkDevice                                    device,
8596     const VkValidationCacheCreateInfoEXT*       pCreateInfo,
8597     const VkAllocationCallbacks*                pAllocator,
8598     VkValidationCacheEXT*                       pValidationCache);
8599 
8600 VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(
8601     VkDevice                                    device,
8602     VkValidationCacheEXT                        validationCache,
8603     const VkAllocationCallbacks*                pAllocator);
8604 
8605 VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(
8606     VkDevice                                    device,
8607     VkValidationCacheEXT                        dstCache,
8608     uint32_t                                    srcCacheCount,
8609     const VkValidationCacheEXT*                 pSrcCaches);
8610 
8611 VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(
8612     VkDevice                                    device,
8613     VkValidationCacheEXT                        validationCache,
8614     size_t*                                     pDataSize,
8615     void*                                       pData);
8616 #endif
8617 
8618 
8619 #define VK_EXT_descriptor_indexing 1
8620 #define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
8621 #define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"
8622 
8623 typedef enum VkDescriptorBindingFlagBitsEXT {
8624     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = 0x00000001,
8625     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = 0x00000002,
8626     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = 0x00000004,
8627     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = 0x00000008,
8628     VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
8629 } VkDescriptorBindingFlagBitsEXT;
8630 typedef VkFlags VkDescriptorBindingFlagsEXT;
8631 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfoEXT {
8632     VkStructureType                       sType;
8633     const void*                           pNext;
8634     uint32_t                              bindingCount;
8635     const VkDescriptorBindingFlagsEXT*    pBindingFlags;
8636 } VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;
8637 
8638 typedef struct VkPhysicalDeviceDescriptorIndexingFeaturesEXT {
8639     VkStructureType    sType;
8640     void*              pNext;
8641     VkBool32           shaderInputAttachmentArrayDynamicIndexing;
8642     VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
8643     VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
8644     VkBool32           shaderUniformBufferArrayNonUniformIndexing;
8645     VkBool32           shaderSampledImageArrayNonUniformIndexing;
8646     VkBool32           shaderStorageBufferArrayNonUniformIndexing;
8647     VkBool32           shaderStorageImageArrayNonUniformIndexing;
8648     VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
8649     VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
8650     VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
8651     VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
8652     VkBool32           descriptorBindingSampledImageUpdateAfterBind;
8653     VkBool32           descriptorBindingStorageImageUpdateAfterBind;
8654     VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
8655     VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
8656     VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
8657     VkBool32           descriptorBindingUpdateUnusedWhilePending;
8658     VkBool32           descriptorBindingPartiallyBound;
8659     VkBool32           descriptorBindingVariableDescriptorCount;
8660     VkBool32           runtimeDescriptorArray;
8661 } VkPhysicalDeviceDescriptorIndexingFeaturesEXT;
8662 
8663 typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT {
8664     VkStructureType    sType;
8665     void*              pNext;
8666     uint32_t           maxUpdateAfterBindDescriptorsInAllPools;
8667     VkBool32           shaderUniformBufferArrayNonUniformIndexingNative;
8668     VkBool32           shaderSampledImageArrayNonUniformIndexingNative;
8669     VkBool32           shaderStorageBufferArrayNonUniformIndexingNative;
8670     VkBool32           shaderStorageImageArrayNonUniformIndexingNative;
8671     VkBool32           shaderInputAttachmentArrayNonUniformIndexingNative;
8672     VkBool32           robustBufferAccessUpdateAfterBind;
8673     VkBool32           quadDivergentImplicitLod;
8674     uint32_t           maxPerStageDescriptorUpdateAfterBindSamplers;
8675     uint32_t           maxPerStageDescriptorUpdateAfterBindUniformBuffers;
8676     uint32_t           maxPerStageDescriptorUpdateAfterBindStorageBuffers;
8677     uint32_t           maxPerStageDescriptorUpdateAfterBindSampledImages;
8678     uint32_t           maxPerStageDescriptorUpdateAfterBindStorageImages;
8679     uint32_t           maxPerStageDescriptorUpdateAfterBindInputAttachments;
8680     uint32_t           maxPerStageUpdateAfterBindResources;
8681     uint32_t           maxDescriptorSetUpdateAfterBindSamplers;
8682     uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffers;
8683     uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
8684     uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffers;
8685     uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
8686     uint32_t           maxDescriptorSetUpdateAfterBindSampledImages;
8687     uint32_t           maxDescriptorSetUpdateAfterBindStorageImages;
8688     uint32_t           maxDescriptorSetUpdateAfterBindInputAttachments;
8689 } VkPhysicalDeviceDescriptorIndexingPropertiesEXT;
8690 
8691 typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfoEXT {
8692     VkStructureType    sType;
8693     const void*        pNext;
8694     uint32_t           descriptorSetCount;
8695     const uint32_t*    pDescriptorCounts;
8696 } VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;
8697 
8698 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT {
8699     VkStructureType    sType;
8700     void*              pNext;
8701     uint32_t           maxVariableDescriptorCount;
8702 } VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;
8703 
8704 
8705 
8706 #define VK_EXT_shader_viewport_index_layer 1
8707 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
8708 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
8709 
8710 
8711 #define VK_NV_shading_rate_image 1
8712 #define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3
8713 #define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"
8714 
8715 typedef enum VkShadingRatePaletteEntryNV {
8716     VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0,
8717     VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1,
8718     VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2,
8719     VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3,
8720     VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4,
8721     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5,
8722     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,
8723     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,
8724     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,
8725     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
8726     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,
8727     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11,
8728     VK_SHADING_RATE_PALETTE_ENTRY_BEGIN_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV,
8729     VK_SHADING_RATE_PALETTE_ENTRY_END_RANGE_NV = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV,
8730     VK_SHADING_RATE_PALETTE_ENTRY_RANGE_SIZE_NV = (VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV - VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV + 1),
8731     VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF
8732 } VkShadingRatePaletteEntryNV;
8733 
8734 typedef enum VkCoarseSampleOrderTypeNV {
8735     VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0,
8736     VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1,
8737     VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2,
8738     VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3,
8739     VK_COARSE_SAMPLE_ORDER_TYPE_BEGIN_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV,
8740     VK_COARSE_SAMPLE_ORDER_TYPE_END_RANGE_NV = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV,
8741     VK_COARSE_SAMPLE_ORDER_TYPE_RANGE_SIZE_NV = (VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV - VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV + 1),
8742     VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8743 } VkCoarseSampleOrderTypeNV;
8744 typedef struct VkShadingRatePaletteNV {
8745     uint32_t                              shadingRatePaletteEntryCount;
8746     const VkShadingRatePaletteEntryNV*    pShadingRatePaletteEntries;
8747 } VkShadingRatePaletteNV;
8748 
8749 typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
8750     VkStructureType                  sType;
8751     const void*                      pNext;
8752     VkBool32                         shadingRateImageEnable;
8753     uint32_t                         viewportCount;
8754     const VkShadingRatePaletteNV*    pShadingRatePalettes;
8755 } VkPipelineViewportShadingRateImageStateCreateInfoNV;
8756 
8757 typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV {
8758     VkStructureType    sType;
8759     void*              pNext;
8760     VkBool32           shadingRateImage;
8761     VkBool32           shadingRateCoarseSampleOrder;
8762 } VkPhysicalDeviceShadingRateImageFeaturesNV;
8763 
8764 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV {
8765     VkStructureType    sType;
8766     void*              pNext;
8767     VkExtent2D         shadingRateTexelSize;
8768     uint32_t           shadingRatePaletteSize;
8769     uint32_t           shadingRateMaxCoarseSamples;
8770 } VkPhysicalDeviceShadingRateImagePropertiesNV;
8771 
8772 typedef struct VkCoarseSampleLocationNV {
8773     uint32_t    pixelX;
8774     uint32_t    pixelY;
8775     uint32_t    sample;
8776 } VkCoarseSampleLocationNV;
8777 
8778 typedef struct VkCoarseSampleOrderCustomNV {
8779     VkShadingRatePaletteEntryNV        shadingRate;
8780     uint32_t                           sampleCount;
8781     uint32_t                           sampleLocationCount;
8782     const VkCoarseSampleLocationNV*    pSampleLocations;
8783 } VkCoarseSampleOrderCustomNV;
8784 
8785 typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
8786     VkStructureType                       sType;
8787     const void*                           pNext;
8788     VkCoarseSampleOrderTypeNV             sampleOrderType;
8789     uint32_t                              customSampleOrderCount;
8790     const VkCoarseSampleOrderCustomNV*    pCustomSampleOrders;
8791 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
8792 
8793 typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
8794 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes);
8795 typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
8796 
8797 #ifndef VK_NO_PROTOTYPES
8798 VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(
8799     VkCommandBuffer                             commandBuffer,
8800     VkImageView                                 imageView,
8801     VkImageLayout                               imageLayout);
8802 
8803 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(
8804     VkCommandBuffer                             commandBuffer,
8805     uint32_t                                    firstViewport,
8806     uint32_t                                    viewportCount,
8807     const VkShadingRatePaletteNV*               pShadingRatePalettes);
8808 
8809 VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(
8810     VkCommandBuffer                             commandBuffer,
8811     VkCoarseSampleOrderTypeNV                   sampleOrderType,
8812     uint32_t                                    customSampleOrderCount,
8813     const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);
8814 #endif
8815 
8816 
8817 #define VK_NV_ray_tracing 1
8818 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)
8819 #define VK_NV_RAY_TRACING_SPEC_VERSION    3
8820 #define VK_NV_RAY_TRACING_EXTENSION_NAME  "VK_NV_ray_tracing"
8821 #define VK_SHADER_UNUSED_NV               (~0U)
8822 
8823 typedef enum VkAccelerationStructureTypeNV {
8824     VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = 0,
8825     VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = 1,
8826     VK_ACCELERATION_STRUCTURE_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV,
8827     VK_ACCELERATION_STRUCTURE_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV,
8828     VK_ACCELERATION_STRUCTURE_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV + 1),
8829     VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8830 } VkAccelerationStructureTypeNV;
8831 
8832 typedef enum VkRayTracingShaderGroupTypeNV {
8833     VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = 0,
8834     VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = 1,
8835     VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = 2,
8836     VK_RAY_TRACING_SHADER_GROUP_TYPE_BEGIN_RANGE_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV,
8837     VK_RAY_TRACING_SHADER_GROUP_TYPE_END_RANGE_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV,
8838     VK_RAY_TRACING_SHADER_GROUP_TYPE_RANGE_SIZE_NV = (VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV + 1),
8839     VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8840 } VkRayTracingShaderGroupTypeNV;
8841 
8842 typedef enum VkGeometryTypeNV {
8843     VK_GEOMETRY_TYPE_TRIANGLES_NV = 0,
8844     VK_GEOMETRY_TYPE_AABBS_NV = 1,
8845     VK_GEOMETRY_TYPE_BEGIN_RANGE_NV = VK_GEOMETRY_TYPE_TRIANGLES_NV,
8846     VK_GEOMETRY_TYPE_END_RANGE_NV = VK_GEOMETRY_TYPE_AABBS_NV,
8847     VK_GEOMETRY_TYPE_RANGE_SIZE_NV = (VK_GEOMETRY_TYPE_AABBS_NV - VK_GEOMETRY_TYPE_TRIANGLES_NV + 1),
8848     VK_GEOMETRY_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8849 } VkGeometryTypeNV;
8850 
8851 typedef enum VkCopyAccelerationStructureModeNV {
8852     VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = 0,
8853     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = 1,
8854     VK_COPY_ACCELERATION_STRUCTURE_MODE_BEGIN_RANGE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV,
8855     VK_COPY_ACCELERATION_STRUCTURE_MODE_END_RANGE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV,
8856     VK_COPY_ACCELERATION_STRUCTURE_MODE_RANGE_SIZE_NV = (VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV + 1),
8857     VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_NV = 0x7FFFFFFF
8858 } VkCopyAccelerationStructureModeNV;
8859 
8860 typedef enum VkAccelerationStructureMemoryRequirementsTypeNV {
8861     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0,
8862     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1,
8863     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2,
8864     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BEGIN_RANGE_NV = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV,
8865     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_END_RANGE_NV = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV,
8866     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_RANGE_SIZE_NV = (VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV + 1),
8867     VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
8868 } VkAccelerationStructureMemoryRequirementsTypeNV;
8869 
8870 typedef enum VkGeometryFlagBitsNV {
8871     VK_GEOMETRY_OPAQUE_BIT_NV = 0x00000001,
8872     VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = 0x00000002,
8873     VK_GEOMETRY_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8874 } VkGeometryFlagBitsNV;
8875 typedef VkFlags VkGeometryFlagsNV;
8876 
8877 typedef enum VkGeometryInstanceFlagBitsNV {
8878     VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = 0x00000001,
8879     VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = 0x00000002,
8880     VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = 0x00000004,
8881     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = 0x00000008,
8882     VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8883 } VkGeometryInstanceFlagBitsNV;
8884 typedef VkFlags VkGeometryInstanceFlagsNV;
8885 
8886 typedef enum VkBuildAccelerationStructureFlagBitsNV {
8887     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = 0x00000001,
8888     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = 0x00000002,
8889     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = 0x00000004,
8890     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = 0x00000008,
8891     VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = 0x00000010,
8892     VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
8893 } VkBuildAccelerationStructureFlagBitsNV;
8894 typedef VkFlags VkBuildAccelerationStructureFlagsNV;
8895 typedef struct VkRayTracingShaderGroupCreateInfoNV {
8896     VkStructureType                  sType;
8897     const void*                      pNext;
8898     VkRayTracingShaderGroupTypeNV    type;
8899     uint32_t                         generalShader;
8900     uint32_t                         closestHitShader;
8901     uint32_t                         anyHitShader;
8902     uint32_t                         intersectionShader;
8903 } VkRayTracingShaderGroupCreateInfoNV;
8904 
8905 typedef struct VkRayTracingPipelineCreateInfoNV {
8906     VkStructureType                               sType;
8907     const void*                                   pNext;
8908     VkPipelineCreateFlags                         flags;
8909     uint32_t                                      stageCount;
8910     const VkPipelineShaderStageCreateInfo*        pStages;
8911     uint32_t                                      groupCount;
8912     const VkRayTracingShaderGroupCreateInfoNV*    pGroups;
8913     uint32_t                                      maxRecursionDepth;
8914     VkPipelineLayout                              layout;
8915     VkPipeline                                    basePipelineHandle;
8916     int32_t                                       basePipelineIndex;
8917 } VkRayTracingPipelineCreateInfoNV;
8918 
8919 typedef struct VkGeometryTrianglesNV {
8920     VkStructureType    sType;
8921     const void*        pNext;
8922     VkBuffer           vertexData;
8923     VkDeviceSize       vertexOffset;
8924     uint32_t           vertexCount;
8925     VkDeviceSize       vertexStride;
8926     VkFormat           vertexFormat;
8927     VkBuffer           indexData;
8928     VkDeviceSize       indexOffset;
8929     uint32_t           indexCount;
8930     VkIndexType        indexType;
8931     VkBuffer           transformData;
8932     VkDeviceSize       transformOffset;
8933 } VkGeometryTrianglesNV;
8934 
8935 typedef struct VkGeometryAABBNV {
8936     VkStructureType    sType;
8937     const void*        pNext;
8938     VkBuffer           aabbData;
8939     uint32_t           numAABBs;
8940     uint32_t           stride;
8941     VkDeviceSize       offset;
8942 } VkGeometryAABBNV;
8943 
8944 typedef struct VkGeometryDataNV {
8945     VkGeometryTrianglesNV    triangles;
8946     VkGeometryAABBNV         aabbs;
8947 } VkGeometryDataNV;
8948 
8949 typedef struct VkGeometryNV {
8950     VkStructureType      sType;
8951     const void*          pNext;
8952     VkGeometryTypeNV     geometryType;
8953     VkGeometryDataNV     geometry;
8954     VkGeometryFlagsNV    flags;
8955 } VkGeometryNV;
8956 
8957 typedef struct VkAccelerationStructureInfoNV {
8958     VkStructureType                        sType;
8959     const void*                            pNext;
8960     VkAccelerationStructureTypeNV          type;
8961     VkBuildAccelerationStructureFlagsNV    flags;
8962     uint32_t                               instanceCount;
8963     uint32_t                               geometryCount;
8964     const VkGeometryNV*                    pGeometries;
8965 } VkAccelerationStructureInfoNV;
8966 
8967 typedef struct VkAccelerationStructureCreateInfoNV {
8968     VkStructureType                  sType;
8969     const void*                      pNext;
8970     VkDeviceSize                     compactedSize;
8971     VkAccelerationStructureInfoNV    info;
8972 } VkAccelerationStructureCreateInfoNV;
8973 
8974 typedef struct VkBindAccelerationStructureMemoryInfoNV {
8975     VkStructureType              sType;
8976     const void*                  pNext;
8977     VkAccelerationStructureNV    accelerationStructure;
8978     VkDeviceMemory               memory;
8979     VkDeviceSize                 memoryOffset;
8980     uint32_t                     deviceIndexCount;
8981     const uint32_t*              pDeviceIndices;
8982 } VkBindAccelerationStructureMemoryInfoNV;
8983 
8984 typedef struct VkWriteDescriptorSetAccelerationStructureNV {
8985     VkStructureType                     sType;
8986     const void*                         pNext;
8987     uint32_t                            accelerationStructureCount;
8988     const VkAccelerationStructureNV*    pAccelerationStructures;
8989 } VkWriteDescriptorSetAccelerationStructureNV;
8990 
8991 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV {
8992     VkStructureType                                    sType;
8993     const void*                                        pNext;
8994     VkAccelerationStructureMemoryRequirementsTypeNV    type;
8995     VkAccelerationStructureNV                          accelerationStructure;
8996 } VkAccelerationStructureMemoryRequirementsInfoNV;
8997 
8998 typedef struct VkPhysicalDeviceRayTracingPropertiesNV {
8999     VkStructureType    sType;
9000     void*              pNext;
9001     uint32_t           shaderGroupHandleSize;
9002     uint32_t           maxRecursionDepth;
9003     uint32_t           maxShaderGroupStride;
9004     uint32_t           shaderGroupBaseAlignment;
9005     uint64_t           maxGeometryCount;
9006     uint64_t           maxInstanceCount;
9007     uint64_t           maxTriangleCount;
9008     uint32_t           maxDescriptorSetAccelerationStructures;
9009 } VkPhysicalDeviceRayTracingPropertiesNV;
9010 
9011 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure);
9012 typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator);
9013 typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
9014 typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
9015 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);
9016 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode);
9017 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);
9018 typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
9019 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
9020 typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData);
9021 typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
9022 typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader);
9023 
9024 #ifndef VK_NO_PROTOTYPES
9025 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(
9026     VkDevice                                    device,
9027     const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
9028     const VkAllocationCallbacks*                pAllocator,
9029     VkAccelerationStructureNV*                  pAccelerationStructure);
9030 
9031 VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(
9032     VkDevice                                    device,
9033     VkAccelerationStructureNV                   accelerationStructure,
9034     const VkAllocationCallbacks*                pAllocator);
9035 
9036 VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(
9037     VkDevice                                    device,
9038     const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
9039     VkMemoryRequirements2KHR*                   pMemoryRequirements);
9040 
9041 VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(
9042     VkDevice                                    device,
9043     uint32_t                                    bindInfoCount,
9044     const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
9045 
9046 VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(
9047     VkCommandBuffer                             commandBuffer,
9048     const VkAccelerationStructureInfoNV*        pInfo,
9049     VkBuffer                                    instanceData,
9050     VkDeviceSize                                instanceOffset,
9051     VkBool32                                    update,
9052     VkAccelerationStructureNV                   dst,
9053     VkAccelerationStructureNV                   src,
9054     VkBuffer                                    scratch,
9055     VkDeviceSize                                scratchOffset);
9056 
9057 VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(
9058     VkCommandBuffer                             commandBuffer,
9059     VkAccelerationStructureNV                   dst,
9060     VkAccelerationStructureNV                   src,
9061     VkCopyAccelerationStructureModeNV           mode);
9062 
9063 VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV(
9064     VkCommandBuffer                             commandBuffer,
9065     VkBuffer                                    raygenShaderBindingTableBuffer,
9066     VkDeviceSize                                raygenShaderBindingOffset,
9067     VkBuffer                                    missShaderBindingTableBuffer,
9068     VkDeviceSize                                missShaderBindingOffset,
9069     VkDeviceSize                                missShaderBindingStride,
9070     VkBuffer                                    hitShaderBindingTableBuffer,
9071     VkDeviceSize                                hitShaderBindingOffset,
9072     VkDeviceSize                                hitShaderBindingStride,
9073     VkBuffer                                    callableShaderBindingTableBuffer,
9074     VkDeviceSize                                callableShaderBindingOffset,
9075     VkDeviceSize                                callableShaderBindingStride,
9076     uint32_t                                    width,
9077     uint32_t                                    height,
9078     uint32_t                                    depth);
9079 
9080 VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(
9081     VkDevice                                    device,
9082     VkPipelineCache                             pipelineCache,
9083     uint32_t                                    createInfoCount,
9084     const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
9085     const VkAllocationCallbacks*                pAllocator,
9086     VkPipeline*                                 pPipelines);
9087 
9088 VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(
9089     VkDevice                                    device,
9090     VkPipeline                                  pipeline,
9091     uint32_t                                    firstGroup,
9092     uint32_t                                    groupCount,
9093     size_t                                      dataSize,
9094     void*                                       pData);
9095 
9096 VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(
9097     VkDevice                                    device,
9098     VkAccelerationStructureNV                   accelerationStructure,
9099     size_t                                      dataSize,
9100     void*                                       pData);
9101 
9102 VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(
9103     VkCommandBuffer                             commandBuffer,
9104     uint32_t                                    accelerationStructureCount,
9105     const VkAccelerationStructureNV*            pAccelerationStructures,
9106     VkQueryType                                 queryType,
9107     VkQueryPool                                 queryPool,
9108     uint32_t                                    firstQuery);
9109 
9110 VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(
9111     VkDevice                                    device,
9112     VkPipeline                                  pipeline,
9113     uint32_t                                    shader);
9114 #endif
9115 
9116 
9117 #define VK_NV_representative_fragment_test 1
9118 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2
9119 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
9120 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
9121     VkStructureType    sType;
9122     void*              pNext;
9123     VkBool32           representativeFragmentTest;
9124 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
9125 
9126 typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
9127     VkStructureType    sType;
9128     const void*        pNext;
9129     VkBool32           representativeFragmentTestEnable;
9130 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
9131 
9132 
9133 
9134 #define VK_EXT_filter_cubic 1
9135 #define VK_EXT_FILTER_CUBIC_SPEC_VERSION  2
9136 #define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic"
9137 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
9138     VkStructureType    sType;
9139     void*              pNext;
9140     VkImageViewType    imageViewType;
9141 } VkPhysicalDeviceImageViewImageFormatInfoEXT;
9142 
9143 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT {
9144     VkStructureType    sType;
9145     void*              pNext;
9146     VkBool32           filterCubic;
9147     VkBool32           filterCubicMinmax ;
9148 } VkFilterCubicImageViewImageFormatPropertiesEXT;
9149 
9150 
9151 
9152 #define VK_EXT_global_priority 1
9153 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
9154 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
9155 
9156 typedef enum VkQueueGlobalPriorityEXT {
9157     VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128,
9158     VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256,
9159     VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512,
9160     VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024,
9161     VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
9162     VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT,
9163     VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1),
9164     VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF
9165 } VkQueueGlobalPriorityEXT;
9166 typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT {
9167     VkStructureType             sType;
9168     const void*                 pNext;
9169     VkQueueGlobalPriorityEXT    globalPriority;
9170 } VkDeviceQueueGlobalPriorityCreateInfoEXT;
9171 
9172 
9173 
9174 #define VK_EXT_external_memory_host 1
9175 #define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
9176 #define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"
9177 typedef struct VkImportMemoryHostPointerInfoEXT {
9178     VkStructureType                       sType;
9179     const void*                           pNext;
9180     VkExternalMemoryHandleTypeFlagBits    handleType;
9181     void*                                 pHostPointer;
9182 } VkImportMemoryHostPointerInfoEXT;
9183 
9184 typedef struct VkMemoryHostPointerPropertiesEXT {
9185     VkStructureType    sType;
9186     void*              pNext;
9187     uint32_t           memoryTypeBits;
9188 } VkMemoryHostPointerPropertiesEXT;
9189 
9190 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
9191     VkStructureType    sType;
9192     void*              pNext;
9193     VkDeviceSize       minImportedHostPointerAlignment;
9194 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
9195 
9196 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
9197 
9198 #ifndef VK_NO_PROTOTYPES
9199 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(
9200     VkDevice                                    device,
9201     VkExternalMemoryHandleTypeFlagBits          handleType,
9202     const void*                                 pHostPointer,
9203     VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
9204 #endif
9205 
9206 
9207 #define VK_AMD_buffer_marker 1
9208 #define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1
9209 #define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"
9210 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
9211 
9212 #ifndef VK_NO_PROTOTYPES
9213 VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(
9214     VkCommandBuffer                             commandBuffer,
9215     VkPipelineStageFlagBits                     pipelineStage,
9216     VkBuffer                                    dstBuffer,
9217     VkDeviceSize                                dstOffset,
9218     uint32_t                                    marker);
9219 #endif
9220 
9221 
9222 #define VK_AMD_pipeline_compiler_control 1
9223 #define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1
9224 #define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control"
9225 
9226 typedef enum VkPipelineCompilerControlFlagBitsAMD {
9227     VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
9228 } VkPipelineCompilerControlFlagBitsAMD;
9229 typedef VkFlags VkPipelineCompilerControlFlagsAMD;
9230 typedef struct VkPipelineCompilerControlCreateInfoAMD {
9231     VkStructureType                      sType;
9232     const void*                          pNext;
9233     VkPipelineCompilerControlFlagsAMD    compilerControlFlags;
9234 } VkPipelineCompilerControlCreateInfoAMD;
9235 
9236 
9237 
9238 #define VK_EXT_calibrated_timestamps 1
9239 #define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1
9240 #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
9241 
9242 typedef enum VkTimeDomainEXT {
9243     VK_TIME_DOMAIN_DEVICE_EXT = 0,
9244     VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,
9245     VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,
9246     VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,
9247     VK_TIME_DOMAIN_BEGIN_RANGE_EXT = VK_TIME_DOMAIN_DEVICE_EXT,
9248     VK_TIME_DOMAIN_END_RANGE_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT,
9249     VK_TIME_DOMAIN_RANGE_SIZE_EXT = (VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT - VK_TIME_DOMAIN_DEVICE_EXT + 1),
9250     VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
9251 } VkTimeDomainEXT;
9252 typedef struct VkCalibratedTimestampInfoEXT {
9253     VkStructureType    sType;
9254     const void*        pNext;
9255     VkTimeDomainEXT    timeDomain;
9256 } VkCalibratedTimestampInfoEXT;
9257 
9258 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);
9259 typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
9260 
9261 #ifndef VK_NO_PROTOTYPES
9262 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
9263     VkPhysicalDevice                            physicalDevice,
9264     uint32_t*                                   pTimeDomainCount,
9265     VkTimeDomainEXT*                            pTimeDomains);
9266 
9267 VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(
9268     VkDevice                                    device,
9269     uint32_t                                    timestampCount,
9270     const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
9271     uint64_t*                                   pTimestamps,
9272     uint64_t*                                   pMaxDeviation);
9273 #endif
9274 
9275 
9276 #define VK_AMD_shader_core_properties 1
9277 #define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2
9278 #define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"
9279 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
9280     VkStructureType    sType;
9281     void*              pNext;
9282     uint32_t           shaderEngineCount;
9283     uint32_t           shaderArraysPerEngineCount;
9284     uint32_t           computeUnitsPerShaderArray;
9285     uint32_t           simdPerComputeUnit;
9286     uint32_t           wavefrontsPerSimd;
9287     uint32_t           wavefrontSize;
9288     uint32_t           sgprsPerSimd;
9289     uint32_t           minSgprAllocation;
9290     uint32_t           maxSgprAllocation;
9291     uint32_t           sgprAllocationGranularity;
9292     uint32_t           vgprsPerSimd;
9293     uint32_t           minVgprAllocation;
9294     uint32_t           maxVgprAllocation;
9295     uint32_t           vgprAllocationGranularity;
9296 } VkPhysicalDeviceShaderCorePropertiesAMD;
9297 
9298 
9299 
9300 #define VK_AMD_memory_overallocation_behavior 1
9301 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1
9302 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior"
9303 
9304 typedef enum VkMemoryOverallocationBehaviorAMD {
9305     VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0,
9306     VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1,
9307     VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2,
9308     VK_MEMORY_OVERALLOCATION_BEHAVIOR_BEGIN_RANGE_AMD = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD,
9309     VK_MEMORY_OVERALLOCATION_BEHAVIOR_END_RANGE_AMD = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD,
9310     VK_MEMORY_OVERALLOCATION_BEHAVIOR_RANGE_SIZE_AMD = (VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD + 1),
9311     VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF
9312 } VkMemoryOverallocationBehaviorAMD;
9313 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD {
9314     VkStructureType                      sType;
9315     const void*                          pNext;
9316     VkMemoryOverallocationBehaviorAMD    overallocationBehavior;
9317 } VkDeviceMemoryOverallocationCreateInfoAMD;
9318 
9319 
9320 
9321 #define VK_EXT_vertex_attribute_divisor 1
9322 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3
9323 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"
9324 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
9325     VkStructureType    sType;
9326     void*              pNext;
9327     uint32_t           maxVertexAttribDivisor;
9328 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
9329 
9330 typedef struct VkVertexInputBindingDivisorDescriptionEXT {
9331     uint32_t    binding;
9332     uint32_t    divisor;
9333 } VkVertexInputBindingDivisorDescriptionEXT;
9334 
9335 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
9336     VkStructureType                                     sType;
9337     const void*                                         pNext;
9338     uint32_t                                            vertexBindingDivisorCount;
9339     const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors;
9340 } VkPipelineVertexInputDivisorStateCreateInfoEXT;
9341 
9342 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
9343     VkStructureType    sType;
9344     void*              pNext;
9345     VkBool32           vertexAttributeInstanceRateDivisor;
9346     VkBool32           vertexAttributeInstanceRateZeroDivisor;
9347 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
9348 
9349 
9350 
9351 #define VK_EXT_pipeline_creation_feedback 1
9352 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1
9353 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback"
9354 
9355 typedef enum VkPipelineCreationFeedbackFlagBitsEXT {
9356     VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 0x00000001,
9357     VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 0x00000002,
9358     VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 0x00000004,
9359     VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
9360 } VkPipelineCreationFeedbackFlagBitsEXT;
9361 typedef VkFlags VkPipelineCreationFeedbackFlagsEXT;
9362 typedef struct VkPipelineCreationFeedbackEXT {
9363     VkPipelineCreationFeedbackFlagsEXT    flags;
9364     uint64_t                              duration;
9365 } VkPipelineCreationFeedbackEXT;
9366 
9367 typedef struct VkPipelineCreationFeedbackCreateInfoEXT {
9368     VkStructureType                   sType;
9369     const void*                       pNext;
9370     VkPipelineCreationFeedbackEXT*    pPipelineCreationFeedback;
9371     uint32_t                          pipelineStageCreationFeedbackCount;
9372     VkPipelineCreationFeedbackEXT*    pPipelineStageCreationFeedbacks;
9373 } VkPipelineCreationFeedbackCreateInfoEXT;
9374 
9375 
9376 
9377 #define VK_NV_shader_subgroup_partitioned 1
9378 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
9379 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"
9380 
9381 
9382 #define VK_NV_compute_shader_derivatives 1
9383 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1
9384 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"
9385 typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
9386     VkStructureType    sType;
9387     void*              pNext;
9388     VkBool32           computeDerivativeGroupQuads;
9389     VkBool32           computeDerivativeGroupLinear;
9390 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
9391 
9392 
9393 
9394 #define VK_NV_mesh_shader 1
9395 #define VK_NV_MESH_SHADER_SPEC_VERSION    1
9396 #define VK_NV_MESH_SHADER_EXTENSION_NAME  "VK_NV_mesh_shader"
9397 typedef struct VkPhysicalDeviceMeshShaderFeaturesNV {
9398     VkStructureType    sType;
9399     void*              pNext;
9400     VkBool32           taskShader;
9401     VkBool32           meshShader;
9402 } VkPhysicalDeviceMeshShaderFeaturesNV;
9403 
9404 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV {
9405     VkStructureType    sType;
9406     void*              pNext;
9407     uint32_t           maxDrawMeshTasksCount;
9408     uint32_t           maxTaskWorkGroupInvocations;
9409     uint32_t           maxTaskWorkGroupSize[3];
9410     uint32_t           maxTaskTotalMemorySize;
9411     uint32_t           maxTaskOutputCount;
9412     uint32_t           maxMeshWorkGroupInvocations;
9413     uint32_t           maxMeshWorkGroupSize[3];
9414     uint32_t           maxMeshTotalMemorySize;
9415     uint32_t           maxMeshOutputVertices;
9416     uint32_t           maxMeshOutputPrimitives;
9417     uint32_t           maxMeshMultiviewViewCount;
9418     uint32_t           meshOutputPerVertexGranularity;
9419     uint32_t           meshOutputPerPrimitiveGranularity;
9420 } VkPhysicalDeviceMeshShaderPropertiesNV;
9421 
9422 typedef struct VkDrawMeshTasksIndirectCommandNV {
9423     uint32_t    taskCount;
9424     uint32_t    firstTask;
9425 } VkDrawMeshTasksIndirectCommandNV;
9426 
9427 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
9428 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
9429 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
9430 
9431 #ifndef VK_NO_PROTOTYPES
9432 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(
9433     VkCommandBuffer                             commandBuffer,
9434     uint32_t                                    taskCount,
9435     uint32_t                                    firstTask);
9436 
9437 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(
9438     VkCommandBuffer                             commandBuffer,
9439     VkBuffer                                    buffer,
9440     VkDeviceSize                                offset,
9441     uint32_t                                    drawCount,
9442     uint32_t                                    stride);
9443 
9444 VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(
9445     VkCommandBuffer                             commandBuffer,
9446     VkBuffer                                    buffer,
9447     VkDeviceSize                                offset,
9448     VkBuffer                                    countBuffer,
9449     VkDeviceSize                                countBufferOffset,
9450     uint32_t                                    maxDrawCount,
9451     uint32_t                                    stride);
9452 #endif
9453 
9454 
9455 #define VK_NV_fragment_shader_barycentric 1
9456 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
9457 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"
9458 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
9459     VkStructureType    sType;
9460     void*              pNext;
9461     VkBool32           fragmentShaderBarycentric;
9462 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
9463 
9464 
9465 
9466 #define VK_NV_shader_image_footprint 1
9467 #define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2
9468 #define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
9469 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
9470     VkStructureType    sType;
9471     void*              pNext;
9472     VkBool32           imageFootprint;
9473 } VkPhysicalDeviceShaderImageFootprintFeaturesNV;
9474 
9475 
9476 
9477 #define VK_NV_scissor_exclusive 1
9478 #define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
9479 #define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"
9480 typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
9481     VkStructureType    sType;
9482     const void*        pNext;
9483     uint32_t           exclusiveScissorCount;
9484     const VkRect2D*    pExclusiveScissors;
9485 } VkPipelineViewportExclusiveScissorStateCreateInfoNV;
9486 
9487 typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
9488     VkStructureType    sType;
9489     void*              pNext;
9490     VkBool32           exclusiveScissor;
9491 } VkPhysicalDeviceExclusiveScissorFeaturesNV;
9492 
9493 typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
9494 
9495 #ifndef VK_NO_PROTOTYPES
9496 VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(
9497     VkCommandBuffer                             commandBuffer,
9498     uint32_t                                    firstExclusiveScissor,
9499     uint32_t                                    exclusiveScissorCount,
9500     const VkRect2D*                             pExclusiveScissors);
9501 #endif
9502 
9503 
9504 #define VK_NV_device_diagnostic_checkpoints 1
9505 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2
9506 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"
9507 typedef struct VkQueueFamilyCheckpointPropertiesNV {
9508     VkStructureType         sType;
9509     void*                   pNext;
9510     VkPipelineStageFlags    checkpointExecutionStageMask;
9511 } VkQueueFamilyCheckpointPropertiesNV;
9512 
9513 typedef struct VkCheckpointDataNV {
9514     VkStructureType            sType;
9515     void*                      pNext;
9516     VkPipelineStageFlagBits    stage;
9517     void*                      pCheckpointMarker;
9518 } VkCheckpointDataNV;
9519 
9520 typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker);
9521 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData);
9522 
9523 #ifndef VK_NO_PROTOTYPES
9524 VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(
9525     VkCommandBuffer                             commandBuffer,
9526     const void*                                 pCheckpointMarker);
9527 
9528 VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(
9529     VkQueue                                     queue,
9530     uint32_t*                                   pCheckpointDataCount,
9531     VkCheckpointDataNV*                         pCheckpointData);
9532 #endif
9533 
9534 
9535 #define VK_INTEL_shader_integer_functions2 1
9536 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1
9537 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
9538 typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
9539     VkStructureType    sType;
9540     void*              pNext;
9541     VkBool32           shaderIntegerFunctions2;
9542 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
9543 
9544 
9545 
9546 #define VK_INTEL_performance_query 1
9547 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)
9548 #define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 1
9549 #define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query"
9550 
9551 typedef enum VkPerformanceConfigurationTypeINTEL {
9552     VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0,
9553     VK_PERFORMANCE_CONFIGURATION_TYPE_BEGIN_RANGE_INTEL = VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL,
9554     VK_PERFORMANCE_CONFIGURATION_TYPE_END_RANGE_INTEL = VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL,
9555     VK_PERFORMANCE_CONFIGURATION_TYPE_RANGE_SIZE_INTEL = (VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL - VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL + 1),
9556     VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
9557 } VkPerformanceConfigurationTypeINTEL;
9558 
9559 typedef enum VkQueryPoolSamplingModeINTEL {
9560     VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0,
9561     VK_QUERY_POOL_SAMPLING_MODE_BEGIN_RANGE_INTEL = VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL,
9562     VK_QUERY_POOL_SAMPLING_MODE_END_RANGE_INTEL = VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL,
9563     VK_QUERY_POOL_SAMPLING_MODE_RANGE_SIZE_INTEL = (VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL - VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL + 1),
9564     VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF
9565 } VkQueryPoolSamplingModeINTEL;
9566 
9567 typedef enum VkPerformanceOverrideTypeINTEL {
9568     VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0,
9569     VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1,
9570     VK_PERFORMANCE_OVERRIDE_TYPE_BEGIN_RANGE_INTEL = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL,
9571     VK_PERFORMANCE_OVERRIDE_TYPE_END_RANGE_INTEL = VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL,
9572     VK_PERFORMANCE_OVERRIDE_TYPE_RANGE_SIZE_INTEL = (VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL - VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL + 1),
9573     VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
9574 } VkPerformanceOverrideTypeINTEL;
9575 
9576 typedef enum VkPerformanceParameterTypeINTEL {
9577     VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0,
9578     VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1,
9579     VK_PERFORMANCE_PARAMETER_TYPE_BEGIN_RANGE_INTEL = VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL,
9580     VK_PERFORMANCE_PARAMETER_TYPE_END_RANGE_INTEL = VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL,
9581     VK_PERFORMANCE_PARAMETER_TYPE_RANGE_SIZE_INTEL = (VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL - VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL + 1),
9582     VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
9583 } VkPerformanceParameterTypeINTEL;
9584 
9585 typedef enum VkPerformanceValueTypeINTEL {
9586     VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,
9587     VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,
9588     VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2,
9589     VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3,
9590     VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,
9591     VK_PERFORMANCE_VALUE_TYPE_BEGIN_RANGE_INTEL = VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL,
9592     VK_PERFORMANCE_VALUE_TYPE_END_RANGE_INTEL = VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL,
9593     VK_PERFORMANCE_VALUE_TYPE_RANGE_SIZE_INTEL = (VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL - VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL + 1),
9594     VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF
9595 } VkPerformanceValueTypeINTEL;
9596 typedef union VkPerformanceValueDataINTEL {
9597     uint32_t       value32;
9598     uint64_t       value64;
9599     float          valueFloat;
9600     VkBool32       valueBool;
9601     const char*    valueString;
9602 } VkPerformanceValueDataINTEL;
9603 
9604 typedef struct VkPerformanceValueINTEL {
9605     VkPerformanceValueTypeINTEL    type;
9606     VkPerformanceValueDataINTEL    data;
9607 } VkPerformanceValueINTEL;
9608 
9609 typedef struct VkInitializePerformanceApiInfoINTEL {
9610     VkStructureType    sType;
9611     const void*        pNext;
9612     void*              pUserData;
9613 } VkInitializePerformanceApiInfoINTEL;
9614 
9615 typedef struct VkQueryPoolCreateInfoINTEL {
9616     VkStructureType                 sType;
9617     const void*                     pNext;
9618     VkQueryPoolSamplingModeINTEL    performanceCountersSampling;
9619 } VkQueryPoolCreateInfoINTEL;
9620 
9621 typedef struct VkPerformanceMarkerInfoINTEL {
9622     VkStructureType    sType;
9623     const void*        pNext;
9624     uint64_t           marker;
9625 } VkPerformanceMarkerInfoINTEL;
9626 
9627 typedef struct VkPerformanceStreamMarkerInfoINTEL {
9628     VkStructureType    sType;
9629     const void*        pNext;
9630     uint32_t           marker;
9631 } VkPerformanceStreamMarkerInfoINTEL;
9632 
9633 typedef struct VkPerformanceOverrideInfoINTEL {
9634     VkStructureType                   sType;
9635     const void*                       pNext;
9636     VkPerformanceOverrideTypeINTEL    type;
9637     VkBool32                          enable;
9638     uint64_t                          parameter;
9639 } VkPerformanceOverrideInfoINTEL;
9640 
9641 typedef struct VkPerformanceConfigurationAcquireInfoINTEL {
9642     VkStructureType                        sType;
9643     const void*                            pNext;
9644     VkPerformanceConfigurationTypeINTEL    type;
9645 } VkPerformanceConfigurationAcquireInfoINTEL;
9646 
9647 typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
9648 typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device);
9649 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
9650 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
9651 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
9652 typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration);
9653 typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration);
9654 typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration);
9655 typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue);
9656 
9657 #ifndef VK_NO_PROTOTYPES
9658 VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(
9659     VkDevice                                    device,
9660     const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);
9661 
9662 VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(
9663     VkDevice                                    device);
9664 
9665 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(
9666     VkCommandBuffer                             commandBuffer,
9667     const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);
9668 
9669 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(
9670     VkCommandBuffer                             commandBuffer,
9671     const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);
9672 
9673 VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(
9674     VkCommandBuffer                             commandBuffer,
9675     const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);
9676 
9677 VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(
9678     VkDevice                                    device,
9679     const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
9680     VkPerformanceConfigurationINTEL*            pConfiguration);
9681 
9682 VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(
9683     VkDevice                                    device,
9684     VkPerformanceConfigurationINTEL             configuration);
9685 
9686 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(
9687     VkQueue                                     queue,
9688     VkPerformanceConfigurationINTEL             configuration);
9689 
9690 VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(
9691     VkDevice                                    device,
9692     VkPerformanceParameterTypeINTEL             parameter,
9693     VkPerformanceValueINTEL*                    pValue);
9694 #endif
9695 
9696 
9697 #define VK_EXT_pci_bus_info 1
9698 #define VK_EXT_PCI_BUS_INFO_SPEC_VERSION  2
9699 #define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info"
9700 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
9701     VkStructureType    sType;
9702     void*              pNext;
9703     uint32_t           pciDomain;
9704     uint32_t           pciBus;
9705     uint32_t           pciDevice;
9706     uint32_t           pciFunction;
9707 } VkPhysicalDevicePCIBusInfoPropertiesEXT;
9708 
9709 
9710 
9711 #define VK_AMD_display_native_hdr 1
9712 #define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1
9713 #define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr"
9714 typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
9715     VkStructureType    sType;
9716     void*              pNext;
9717     VkBool32           localDimmingSupport;
9718 } VkDisplayNativeHdrSurfaceCapabilitiesAMD;
9719 
9720 typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
9721     VkStructureType    sType;
9722     const void*        pNext;
9723     VkBool32           localDimmingEnable;
9724 } VkSwapchainDisplayNativeHdrCreateInfoAMD;
9725 
9726 typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable);
9727 
9728 #ifndef VK_NO_PROTOTYPES
9729 VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(
9730     VkDevice                                    device,
9731     VkSwapchainKHR                              swapChain,
9732     VkBool32                                    localDimmingEnable);
9733 #endif
9734 
9735 
9736 #define VK_EXT_fragment_density_map 1
9737 #define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 1
9738 #define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map"
9739 typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
9740     VkStructureType    sType;
9741     void*              pNext;
9742     VkBool32           fragmentDensityMap;
9743     VkBool32           fragmentDensityMapDynamic;
9744     VkBool32           fragmentDensityMapNonSubsampledImages;
9745 } VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
9746 
9747 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
9748     VkStructureType    sType;
9749     void*              pNext;
9750     VkExtent2D         minFragmentDensityTexelSize;
9751     VkExtent2D         maxFragmentDensityTexelSize;
9752     VkBool32           fragmentDensityInvocations;
9753 } VkPhysicalDeviceFragmentDensityMapPropertiesEXT;
9754 
9755 typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT {
9756     VkStructureType          sType;
9757     const void*              pNext;
9758     VkAttachmentReference    fragmentDensityMapAttachment;
9759 } VkRenderPassFragmentDensityMapCreateInfoEXT;
9760 
9761 
9762 
9763 #define VK_EXT_scalar_block_layout 1
9764 #define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1
9765 #define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout"
9766 typedef struct VkPhysicalDeviceScalarBlockLayoutFeaturesEXT {
9767     VkStructureType    sType;
9768     void*              pNext;
9769     VkBool32           scalarBlockLayout;
9770 } VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;
9771 
9772 
9773 
9774 #define VK_GOOGLE_hlsl_functionality1 1
9775 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION 1
9776 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1"
9777 
9778 
9779 #define VK_GOOGLE_decorate_string 1
9780 #define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1
9781 #define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"
9782 
9783 
9784 #define VK_EXT_subgroup_size_control 1
9785 #define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2
9786 #define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"
9787 typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
9788     VkStructureType    sType;
9789     void*              pNext;
9790     VkBool32           subgroupSizeControl;
9791     VkBool32           computeFullSubgroups;
9792 } VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;
9793 
9794 typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
9795     VkStructureType       sType;
9796     void*                 pNext;
9797     uint32_t              minSubgroupSize;
9798     uint32_t              maxSubgroupSize;
9799     uint32_t              maxComputeWorkgroupSubgroups;
9800     VkShaderStageFlags    requiredSubgroupSizeStages;
9801 } VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;
9802 
9803 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
9804     VkStructureType    sType;
9805     void*              pNext;
9806     uint32_t           requiredSubgroupSize;
9807 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
9808 
9809 
9810 
9811 #define VK_AMD_shader_core_properties2 1
9812 #define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1
9813 #define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2"
9814 
9815 typedef enum VkShaderCorePropertiesFlagBitsAMD {
9816     VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF
9817 } VkShaderCorePropertiesFlagBitsAMD;
9818 typedef VkFlags VkShaderCorePropertiesFlagsAMD;
9819 typedef struct VkPhysicalDeviceShaderCoreProperties2AMD {
9820     VkStructureType                   sType;
9821     void*                             pNext;
9822     VkShaderCorePropertiesFlagsAMD    shaderCoreFeatures;
9823     uint32_t                          activeComputeUnitCount;
9824 } VkPhysicalDeviceShaderCoreProperties2AMD;
9825 
9826 
9827 
9828 #define VK_AMD_device_coherent_memory 1
9829 #define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1
9830 #define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory"
9831 typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
9832     VkStructureType    sType;
9833     void*              pNext;
9834     VkBool32           deviceCoherentMemory;
9835 } VkPhysicalDeviceCoherentMemoryFeaturesAMD;
9836 
9837 
9838 
9839 #define VK_EXT_memory_budget 1
9840 #define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1
9841 #define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"
9842 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
9843     VkStructureType    sType;
9844     void*              pNext;
9845     VkDeviceSize       heapBudget[VK_MAX_MEMORY_HEAPS];
9846     VkDeviceSize       heapUsage[VK_MAX_MEMORY_HEAPS];
9847 } VkPhysicalDeviceMemoryBudgetPropertiesEXT;
9848 
9849 
9850 
9851 #define VK_EXT_memory_priority 1
9852 #define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1
9853 #define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority"
9854 typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
9855     VkStructureType    sType;
9856     void*              pNext;
9857     VkBool32           memoryPriority;
9858 } VkPhysicalDeviceMemoryPriorityFeaturesEXT;
9859 
9860 typedef struct VkMemoryPriorityAllocateInfoEXT {
9861     VkStructureType    sType;
9862     const void*        pNext;
9863     float              priority;
9864 } VkMemoryPriorityAllocateInfoEXT;
9865 
9866 
9867 
9868 #define VK_NV_dedicated_allocation_image_aliasing 1
9869 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1
9870 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing"
9871 typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
9872     VkStructureType    sType;
9873     void*              pNext;
9874     VkBool32           dedicatedAllocationImageAliasing;
9875 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
9876 
9877 
9878 
9879 #define VK_EXT_buffer_device_address 1
9880 #define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2
9881 #define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
9882 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
9883     VkStructureType    sType;
9884     void*              pNext;
9885     VkBool32           bufferDeviceAddress;
9886     VkBool32           bufferDeviceAddressCaptureReplay;
9887     VkBool32           bufferDeviceAddressMultiDevice;
9888 } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
9889 
9890 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;
9891 
9892 typedef VkBufferDeviceAddressInfoKHR VkBufferDeviceAddressInfoEXT;
9893 
9894 typedef struct VkBufferDeviceAddressCreateInfoEXT {
9895     VkStructureType    sType;
9896     const void*        pNext;
9897     VkDeviceAddress    deviceAddress;
9898 } VkBufferDeviceAddressCreateInfoEXT;
9899 
9900 typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
9901 
9902 #ifndef VK_NO_PROTOTYPES
9903 VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(
9904     VkDevice                                    device,
9905     const VkBufferDeviceAddressInfoKHR*         pInfo);
9906 #endif
9907 
9908 
9909 #define VK_EXT_tooling_info 1
9910 #define VK_EXT_TOOLING_INFO_SPEC_VERSION  1
9911 #define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info"
9912 
9913 typedef enum VkToolPurposeFlagBitsEXT {
9914     VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 0x00000001,
9915     VK_TOOL_PURPOSE_PROFILING_BIT_EXT = 0x00000002,
9916     VK_TOOL_PURPOSE_TRACING_BIT_EXT = 0x00000004,
9917     VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 0x00000008,
9918     VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 0x00000010,
9919     VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020,
9920     VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040,
9921     VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
9922 } VkToolPurposeFlagBitsEXT;
9923 typedef VkFlags VkToolPurposeFlagsEXT;
9924 typedef struct VkPhysicalDeviceToolPropertiesEXT {
9925     VkStructureType          sType;
9926     void*                    pNext;
9927     char                     name[VK_MAX_EXTENSION_NAME_SIZE];
9928     char                     version[VK_MAX_EXTENSION_NAME_SIZE];
9929     VkToolPurposeFlagsEXT    purposes;
9930     char                     description[VK_MAX_DESCRIPTION_SIZE];
9931     char                     layer[VK_MAX_EXTENSION_NAME_SIZE];
9932 } VkPhysicalDeviceToolPropertiesEXT;
9933 
9934 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolPropertiesEXT* pToolProperties);
9935 
9936 #ifndef VK_NO_PROTOTYPES
9937 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(
9938     VkPhysicalDevice                            physicalDevice,
9939     uint32_t*                                   pToolCount,
9940     VkPhysicalDeviceToolPropertiesEXT*          pToolProperties);
9941 #endif
9942 
9943 
9944 #define VK_EXT_separate_stencil_usage 1
9945 #define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1
9946 #define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage"
9947 typedef struct VkImageStencilUsageCreateInfoEXT {
9948     VkStructureType      sType;
9949     const void*          pNext;
9950     VkImageUsageFlags    stencilUsage;
9951 } VkImageStencilUsageCreateInfoEXT;
9952 
9953 
9954 
9955 #define VK_EXT_validation_features 1
9956 #define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 2
9957 #define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"
9958 
9959 typedef enum VkValidationFeatureEnableEXT {
9960     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,
9961     VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,
9962     VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2,
9963     VK_VALIDATION_FEATURE_ENABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT,
9964     VK_VALIDATION_FEATURE_ENABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT,
9965     VK_VALIDATION_FEATURE_ENABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT + 1),
9966     VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF
9967 } VkValidationFeatureEnableEXT;
9968 
9969 typedef enum VkValidationFeatureDisableEXT {
9970     VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,
9971     VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,
9972     VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,
9973     VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,
9974     VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,
9975     VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,
9976     VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,
9977     VK_VALIDATION_FEATURE_DISABLE_BEGIN_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT,
9978     VK_VALIDATION_FEATURE_DISABLE_END_RANGE_EXT = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT,
9979     VK_VALIDATION_FEATURE_DISABLE_RANGE_SIZE_EXT = (VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT - VK_VALIDATION_FEATURE_DISABLE_ALL_EXT + 1),
9980     VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF
9981 } VkValidationFeatureDisableEXT;
9982 typedef struct VkValidationFeaturesEXT {
9983     VkStructureType                         sType;
9984     const void*                             pNext;
9985     uint32_t                                enabledValidationFeatureCount;
9986     const VkValidationFeatureEnableEXT*     pEnabledValidationFeatures;
9987     uint32_t                                disabledValidationFeatureCount;
9988     const VkValidationFeatureDisableEXT*    pDisabledValidationFeatures;
9989 } VkValidationFeaturesEXT;
9990 
9991 
9992 
9993 #define VK_NV_cooperative_matrix 1
9994 #define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1
9995 #define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix"
9996 
9997 typedef enum VkComponentTypeNV {
9998     VK_COMPONENT_TYPE_FLOAT16_NV = 0,
9999     VK_COMPONENT_TYPE_FLOAT32_NV = 1,
10000     VK_COMPONENT_TYPE_FLOAT64_NV = 2,
10001     VK_COMPONENT_TYPE_SINT8_NV = 3,
10002     VK_COMPONENT_TYPE_SINT16_NV = 4,
10003     VK_COMPONENT_TYPE_SINT32_NV = 5,
10004     VK_COMPONENT_TYPE_SINT64_NV = 6,
10005     VK_COMPONENT_TYPE_UINT8_NV = 7,
10006     VK_COMPONENT_TYPE_UINT16_NV = 8,
10007     VK_COMPONENT_TYPE_UINT32_NV = 9,
10008     VK_COMPONENT_TYPE_UINT64_NV = 10,
10009     VK_COMPONENT_TYPE_BEGIN_RANGE_NV = VK_COMPONENT_TYPE_FLOAT16_NV,
10010     VK_COMPONENT_TYPE_END_RANGE_NV = VK_COMPONENT_TYPE_UINT64_NV,
10011     VK_COMPONENT_TYPE_RANGE_SIZE_NV = (VK_COMPONENT_TYPE_UINT64_NV - VK_COMPONENT_TYPE_FLOAT16_NV + 1),
10012     VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF
10013 } VkComponentTypeNV;
10014 
10015 typedef enum VkScopeNV {
10016     VK_SCOPE_DEVICE_NV = 1,
10017     VK_SCOPE_WORKGROUP_NV = 2,
10018     VK_SCOPE_SUBGROUP_NV = 3,
10019     VK_SCOPE_QUEUE_FAMILY_NV = 5,
10020     VK_SCOPE_BEGIN_RANGE_NV = VK_SCOPE_DEVICE_NV,
10021     VK_SCOPE_END_RANGE_NV = VK_SCOPE_QUEUE_FAMILY_NV,
10022     VK_SCOPE_RANGE_SIZE_NV = (VK_SCOPE_QUEUE_FAMILY_NV - VK_SCOPE_DEVICE_NV + 1),
10023     VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF
10024 } VkScopeNV;
10025 typedef struct VkCooperativeMatrixPropertiesNV {
10026     VkStructureType      sType;
10027     void*                pNext;
10028     uint32_t             MSize;
10029     uint32_t             NSize;
10030     uint32_t             KSize;
10031     VkComponentTypeNV    AType;
10032     VkComponentTypeNV    BType;
10033     VkComponentTypeNV    CType;
10034     VkComponentTypeNV    DType;
10035     VkScopeNV            scope;
10036 } VkCooperativeMatrixPropertiesNV;
10037 
10038 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
10039     VkStructureType    sType;
10040     void*              pNext;
10041     VkBool32           cooperativeMatrix;
10042     VkBool32           cooperativeMatrixRobustBufferAccess;
10043 } VkPhysicalDeviceCooperativeMatrixFeaturesNV;
10044 
10045 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
10046     VkStructureType       sType;
10047     void*                 pNext;
10048     VkShaderStageFlags    cooperativeMatrixSupportedStages;
10049 } VkPhysicalDeviceCooperativeMatrixPropertiesNV;
10050 
10051 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties);
10052 
10053 #ifndef VK_NO_PROTOTYPES
10054 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
10055     VkPhysicalDevice                            physicalDevice,
10056     uint32_t*                                   pPropertyCount,
10057     VkCooperativeMatrixPropertiesNV*            pProperties);
10058 #endif
10059 
10060 
10061 #define VK_NV_coverage_reduction_mode 1
10062 #define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1
10063 #define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode"
10064 
10065 typedef enum VkCoverageReductionModeNV {
10066     VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0,
10067     VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1,
10068     VK_COVERAGE_REDUCTION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_REDUCTION_MODE_MERGE_NV,
10069     VK_COVERAGE_REDUCTION_MODE_END_RANGE_NV = VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV,
10070     VK_COVERAGE_REDUCTION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV - VK_COVERAGE_REDUCTION_MODE_MERGE_NV + 1),
10071     VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
10072 } VkCoverageReductionModeNV;
10073 typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;
10074 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
10075     VkStructureType    sType;
10076     void*              pNext;
10077     VkBool32           coverageReductionMode;
10078 } VkPhysicalDeviceCoverageReductionModeFeaturesNV;
10079 
10080 typedef struct VkPipelineCoverageReductionStateCreateInfoNV {
10081     VkStructureType                                  sType;
10082     const void*                                      pNext;
10083     VkPipelineCoverageReductionStateCreateFlagsNV    flags;
10084     VkCoverageReductionModeNV                        coverageReductionMode;
10085 } VkPipelineCoverageReductionStateCreateInfoNV;
10086 
10087 typedef struct VkFramebufferMixedSamplesCombinationNV {
10088     VkStructureType              sType;
10089     void*                        pNext;
10090     VkCoverageReductionModeNV    coverageReductionMode;
10091     VkSampleCountFlagBits        rasterizationSamples;
10092     VkSampleCountFlags           depthStencilSamples;
10093     VkSampleCountFlags           colorSamples;
10094 } VkFramebufferMixedSamplesCombinationNV;
10095 
10096 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations);
10097 
10098 #ifndef VK_NO_PROTOTYPES
10099 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
10100     VkPhysicalDevice                            physicalDevice,
10101     uint32_t*                                   pCombinationCount,
10102     VkFramebufferMixedSamplesCombinationNV*     pCombinations);
10103 #endif
10104 
10105 
10106 #define VK_EXT_fragment_shader_interlock 1
10107 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1
10108 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock"
10109 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
10110     VkStructureType    sType;
10111     void*              pNext;
10112     VkBool32           fragmentShaderSampleInterlock;
10113     VkBool32           fragmentShaderPixelInterlock;
10114     VkBool32           fragmentShaderShadingRateInterlock;
10115 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
10116 
10117 
10118 
10119 #define VK_EXT_ycbcr_image_arrays 1
10120 #define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1
10121 #define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
10122 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
10123     VkStructureType    sType;
10124     void*              pNext;
10125     VkBool32           ycbcrImageArrays;
10126 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
10127 
10128 
10129 
10130 #define VK_EXT_headless_surface 1
10131 #define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1
10132 #define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface"
10133 typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
10134 typedef struct VkHeadlessSurfaceCreateInfoEXT {
10135     VkStructureType                    sType;
10136     const void*                        pNext;
10137     VkHeadlessSurfaceCreateFlagsEXT    flags;
10138 } VkHeadlessSurfaceCreateInfoEXT;
10139 
10140 typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
10141 
10142 #ifndef VK_NO_PROTOTYPES
10143 VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(
10144     VkInstance                                  instance,
10145     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
10146     const VkAllocationCallbacks*                pAllocator,
10147     VkSurfaceKHR*                               pSurface);
10148 #endif
10149 
10150 
10151 #define VK_EXT_line_rasterization 1
10152 #define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
10153 #define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
10154 
10155 typedef enum VkLineRasterizationModeEXT {
10156     VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
10157     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
10158     VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
10159     VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
10160     VK_LINE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT,
10161     VK_LINE_RASTERIZATION_MODE_END_RANGE_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT,
10162     VK_LINE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT + 1),
10163     VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
10164 } VkLineRasterizationModeEXT;
10165 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
10166     VkStructureType    sType;
10167     void*              pNext;
10168     VkBool32           rectangularLines;
10169     VkBool32           bresenhamLines;
10170     VkBool32           smoothLines;
10171     VkBool32           stippledRectangularLines;
10172     VkBool32           stippledBresenhamLines;
10173     VkBool32           stippledSmoothLines;
10174 } VkPhysicalDeviceLineRasterizationFeaturesEXT;
10175 
10176 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
10177     VkStructureType    sType;
10178     void*              pNext;
10179     uint32_t           lineSubPixelPrecisionBits;
10180 } VkPhysicalDeviceLineRasterizationPropertiesEXT;
10181 
10182 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
10183     VkStructureType               sType;
10184     const void*                   pNext;
10185     VkLineRasterizationModeEXT    lineRasterizationMode;
10186     VkBool32                      stippledLineEnable;
10187     uint32_t                      lineStippleFactor;
10188     uint16_t                      lineStipplePattern;
10189 } VkPipelineRasterizationLineStateCreateInfoEXT;
10190 
10191 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
10192 
10193 #ifndef VK_NO_PROTOTYPES
10194 VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(
10195     VkCommandBuffer                             commandBuffer,
10196     uint32_t                                    lineStippleFactor,
10197     uint16_t                                    lineStipplePattern);
10198 #endif
10199 
10200 
10201 #define VK_EXT_host_query_reset 1
10202 #define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1
10203 #define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset"
10204 typedef struct VkPhysicalDeviceHostQueryResetFeaturesEXT {
10205     VkStructureType    sType;
10206     void*              pNext;
10207     VkBool32           hostQueryReset;
10208 } VkPhysicalDeviceHostQueryResetFeaturesEXT;
10209 
10210 typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
10211 
10212 #ifndef VK_NO_PROTOTYPES
10213 VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(
10214     VkDevice                                    device,
10215     VkQueryPool                                 queryPool,
10216     uint32_t                                    firstQuery,
10217     uint32_t                                    queryCount);
10218 #endif
10219 
10220 
10221 #define VK_EXT_index_type_uint8 1
10222 #define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
10223 #define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
10224 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
10225     VkStructureType    sType;
10226     void*              pNext;
10227     VkBool32           indexTypeUint8;
10228 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
10229 
10230 
10231 
10232 #define VK_EXT_shader_demote_to_helper_invocation 1
10233 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1
10234 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"
10235 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
10236     VkStructureType    sType;
10237     void*              pNext;
10238     VkBool32           shaderDemoteToHelperInvocation;
10239 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
10240 
10241 
10242 
10243 #define VK_EXT_texel_buffer_alignment 1
10244 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1
10245 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment"
10246 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
10247     VkStructureType    sType;
10248     void*              pNext;
10249     VkBool32           texelBufferAlignment;
10250 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
10251 
10252 typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT {
10253     VkStructureType    sType;
10254     void*              pNext;
10255     VkDeviceSize       storageTexelBufferOffsetAlignmentBytes;
10256     VkBool32           storageTexelBufferOffsetSingleTexelAlignment;
10257     VkDeviceSize       uniformTexelBufferOffsetAlignmentBytes;
10258     VkBool32           uniformTexelBufferOffsetSingleTexelAlignment;
10259 } VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
10260 
10261 
10262 
10263 #define VK_GOOGLE_user_type 1
10264 #define VK_GOOGLE_USER_TYPE_SPEC_VERSION  1
10265 #define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type"
10266 
10267 #ifdef __cplusplus
10268 }
10269 #endif
10270 
10271 #endif
10272