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