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