1#ifndef VULKAN_H_
2#define VULKAN_H_ 1
3
4#ifdef __cplusplus
5extern "C" {
6#endif
7
8/*
9** Copyright (c) 2015-2017 The Khronos Group Inc.
10**
11** Licensed under the Apache License, Version 2.0 (the "License");
12** you may not use this file except in compliance with the License.
13** You may obtain a copy of the License at
14**
15**     http://www.apache.org/licenses/LICENSE-2.0
16**
17** Unless required by applicable law or agreed to in writing, software
18** distributed under the License is distributed on an "AS IS" BASIS,
19** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20** See the License for the specific language governing permissions and
21** limitations under the License.
22*/
23
24/*
25** This header is generated from the Khronos Vulkan XML API Registry.
26**
27*/
28
29
30#define VK_VERSION_1_0 1
31#include "vk_platform.h"
32
33#define VK_MAKE_VERSION(major, minor, patch) \
34    (((major) << 22) | ((minor) << 12) | (patch))
35
36// 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.
37//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0)
38
39// Vulkan 1.0 version number
40#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)
41
42#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
43#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
44#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
45// Version of this file
46#define VK_HEADER_VERSION 46
47
48
49#define VK_NULL_HANDLE 0
50
51
52
53#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
54
55
56#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
57#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
58        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
59#else
60        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
61#endif
62#endif
63
64
65
66typedef uint32_t VkFlags;
67typedef uint32_t VkBool32;
68typedef uint64_t VkDeviceSize;
69typedef uint32_t VkSampleMask;
70
71VK_DEFINE_HANDLE(VkInstance)
72VK_DEFINE_HANDLE(VkPhysicalDevice)
73VK_DEFINE_HANDLE(VkDevice)
74VK_DEFINE_HANDLE(VkQueue)
75VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
76VK_DEFINE_HANDLE(VkCommandBuffer)
77VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
78VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
79VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
80VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
81VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
82VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
83VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
84VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
85VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
86VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
87VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
88VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
89VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
90VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
91VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
92VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
93VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
94VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
95VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
96
97#define VK_LOD_CLAMP_NONE                 1000.0f
98#define VK_REMAINING_MIP_LEVELS           (~0U)
99#define VK_REMAINING_ARRAY_LAYERS         (~0U)
100#define VK_WHOLE_SIZE                     (~0ULL)
101#define VK_ATTACHMENT_UNUSED              (~0U)
102#define VK_TRUE                           1
103#define VK_FALSE                          0
104#define VK_QUEUE_FAMILY_IGNORED           (~0U)
105#define VK_SUBPASS_EXTERNAL               (~0U)
106#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
107#define VK_UUID_SIZE                      16
108#define VK_MAX_MEMORY_TYPES               32
109#define VK_MAX_MEMORY_HEAPS               16
110#define VK_MAX_EXTENSION_NAME_SIZE        256
111#define VK_MAX_DESCRIPTION_SIZE           256
112
113
114typedef enum VkPipelineCacheHeaderVersion {
115    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
116    VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
117    VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
118    VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
119    VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
120} VkPipelineCacheHeaderVersion;
121
122typedef enum VkResult {
123    VK_SUCCESS = 0,
124    VK_NOT_READY = 1,
125    VK_TIMEOUT = 2,
126    VK_EVENT_SET = 3,
127    VK_EVENT_RESET = 4,
128    VK_INCOMPLETE = 5,
129    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
130    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
131    VK_ERROR_INITIALIZATION_FAILED = -3,
132    VK_ERROR_DEVICE_LOST = -4,
133    VK_ERROR_MEMORY_MAP_FAILED = -5,
134    VK_ERROR_LAYER_NOT_PRESENT = -6,
135    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
136    VK_ERROR_FEATURE_NOT_PRESENT = -8,
137    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
138    VK_ERROR_TOO_MANY_OBJECTS = -10,
139    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
140    VK_ERROR_FRAGMENTED_POOL = -12,
141    VK_ERROR_SURFACE_LOST_KHR = -1000000000,
142    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
143    VK_SUBOPTIMAL_KHR = 1000001003,
144    VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
145    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
146    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
147    VK_ERROR_INVALID_SHADER_NV = -1000012000,
148    VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
149    VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX = -1000072003,
150    VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
151    VK_RESULT_END_RANGE = VK_INCOMPLETE,
152    VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
153    VK_RESULT_MAX_ENUM = 0x7FFFFFFF
154} VkResult;
155
156typedef enum VkStructureType {
157    VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
158    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
159    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
160    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
161    VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
162    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
163    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
164    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
165    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
166    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
167    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
168    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
169    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
170    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
171    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
172    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
173    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
174    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
175    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
176    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
177    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
178    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
179    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
180    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
181    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
182    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
183    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
184    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
185    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
186    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
187    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
188    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
189    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
190    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
191    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
192    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
193    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
194    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
195    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
196    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
197    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
198    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
199    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
200    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
201    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
202    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
203    VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
204    VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
205    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
206    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
207    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
208    VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
209    VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
210    VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
211    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
212    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
213    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
214    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
215    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
216    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
217    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
218    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
219    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
220    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
221    VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
222    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
223    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
224    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
225    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000,
226    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001,
227    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002,
228    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
229    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
230    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
231    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
232    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
233    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
234    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
235    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002,
236    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003,
237    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004,
238    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005,
239    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
240    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
241    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
242    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = 1000060000,
243    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX = 1000060001,
244    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX = 1000060002,
245    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = 1000060003,
246    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004,
247    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = 1000060005,
248    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = 1000060006,
249    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007,
250    VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = 1000060008,
251    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = 1000060009,
252    VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = 1000060010,
253    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = 1000060011,
254    VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012,
255    VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
256    VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
257    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000,
258    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001,
259    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX = 1000071000,
260    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX = 1000071001,
261    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX = 1000071002,
262    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX = 1000071003,
263    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX = 1000071004,
264    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX = 1000071005,
265    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX = 1000071006,
266    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX = 1000071007,
267    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX = 1000072000,
268    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX = 1000072001,
269    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX = 1000072002,
270    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073000,
271    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073001,
272    VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX = 1000073002,
273    VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX = 1000074000,
274    VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX = 1000074001,
275    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX = 1000075000,
276    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX = 1000076000,
277    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX = 1000076001,
278    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX = 1000077000,
279    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078000,
280    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001,
281    VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002,
282    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000,
283    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
284    VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
285    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
286    VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
287    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
288    VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
289    VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
290    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
291    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
292    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
293    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = 1000090000,
294    VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
295    VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
296    VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
297    VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
298    VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
299    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
300    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
301    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
302    VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
303    VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
304    VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
305    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
306    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
307    VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
308    VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
309    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
310    VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
311    VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
312    VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
313    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
314} VkStructureType;
315
316typedef enum VkSystemAllocationScope {
317    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
318    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
319    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
320    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
321    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
322    VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
323    VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
324    VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
325    VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
326} VkSystemAllocationScope;
327
328typedef enum VkInternalAllocationType {
329    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
330    VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
331    VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
332    VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
333    VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
334} VkInternalAllocationType;
335
336typedef enum VkFormat {
337    VK_FORMAT_UNDEFINED = 0,
338    VK_FORMAT_R4G4_UNORM_PACK8 = 1,
339    VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
340    VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
341    VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
342    VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
343    VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
344    VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
345    VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
346    VK_FORMAT_R8_UNORM = 9,
347    VK_FORMAT_R8_SNORM = 10,
348    VK_FORMAT_R8_USCALED = 11,
349    VK_FORMAT_R8_SSCALED = 12,
350    VK_FORMAT_R8_UINT = 13,
351    VK_FORMAT_R8_SINT = 14,
352    VK_FORMAT_R8_SRGB = 15,
353    VK_FORMAT_R8G8_UNORM = 16,
354    VK_FORMAT_R8G8_SNORM = 17,
355    VK_FORMAT_R8G8_USCALED = 18,
356    VK_FORMAT_R8G8_SSCALED = 19,
357    VK_FORMAT_R8G8_UINT = 20,
358    VK_FORMAT_R8G8_SINT = 21,
359    VK_FORMAT_R8G8_SRGB = 22,
360    VK_FORMAT_R8G8B8_UNORM = 23,
361    VK_FORMAT_R8G8B8_SNORM = 24,
362    VK_FORMAT_R8G8B8_USCALED = 25,
363    VK_FORMAT_R8G8B8_SSCALED = 26,
364    VK_FORMAT_R8G8B8_UINT = 27,
365    VK_FORMAT_R8G8B8_SINT = 28,
366    VK_FORMAT_R8G8B8_SRGB = 29,
367    VK_FORMAT_B8G8R8_UNORM = 30,
368    VK_FORMAT_B8G8R8_SNORM = 31,
369    VK_FORMAT_B8G8R8_USCALED = 32,
370    VK_FORMAT_B8G8R8_SSCALED = 33,
371    VK_FORMAT_B8G8R8_UINT = 34,
372    VK_FORMAT_B8G8R8_SINT = 35,
373    VK_FORMAT_B8G8R8_SRGB = 36,
374    VK_FORMAT_R8G8B8A8_UNORM = 37,
375    VK_FORMAT_R8G8B8A8_SNORM = 38,
376    VK_FORMAT_R8G8B8A8_USCALED = 39,
377    VK_FORMAT_R8G8B8A8_SSCALED = 40,
378    VK_FORMAT_R8G8B8A8_UINT = 41,
379    VK_FORMAT_R8G8B8A8_SINT = 42,
380    VK_FORMAT_R8G8B8A8_SRGB = 43,
381    VK_FORMAT_B8G8R8A8_UNORM = 44,
382    VK_FORMAT_B8G8R8A8_SNORM = 45,
383    VK_FORMAT_B8G8R8A8_USCALED = 46,
384    VK_FORMAT_B8G8R8A8_SSCALED = 47,
385    VK_FORMAT_B8G8R8A8_UINT = 48,
386    VK_FORMAT_B8G8R8A8_SINT = 49,
387    VK_FORMAT_B8G8R8A8_SRGB = 50,
388    VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
389    VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
390    VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
391    VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
392    VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
393    VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
394    VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
395    VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
396    VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
397    VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
398    VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
399    VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
400    VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
401    VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
402    VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
403    VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
404    VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
405    VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
406    VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
407    VK_FORMAT_R16_UNORM = 70,
408    VK_FORMAT_R16_SNORM = 71,
409    VK_FORMAT_R16_USCALED = 72,
410    VK_FORMAT_R16_SSCALED = 73,
411    VK_FORMAT_R16_UINT = 74,
412    VK_FORMAT_R16_SINT = 75,
413    VK_FORMAT_R16_SFLOAT = 76,
414    VK_FORMAT_R16G16_UNORM = 77,
415    VK_FORMAT_R16G16_SNORM = 78,
416    VK_FORMAT_R16G16_USCALED = 79,
417    VK_FORMAT_R16G16_SSCALED = 80,
418    VK_FORMAT_R16G16_UINT = 81,
419    VK_FORMAT_R16G16_SINT = 82,
420    VK_FORMAT_R16G16_SFLOAT = 83,
421    VK_FORMAT_R16G16B16_UNORM = 84,
422    VK_FORMAT_R16G16B16_SNORM = 85,
423    VK_FORMAT_R16G16B16_USCALED = 86,
424    VK_FORMAT_R16G16B16_SSCALED = 87,
425    VK_FORMAT_R16G16B16_UINT = 88,
426    VK_FORMAT_R16G16B16_SINT = 89,
427    VK_FORMAT_R16G16B16_SFLOAT = 90,
428    VK_FORMAT_R16G16B16A16_UNORM = 91,
429    VK_FORMAT_R16G16B16A16_SNORM = 92,
430    VK_FORMAT_R16G16B16A16_USCALED = 93,
431    VK_FORMAT_R16G16B16A16_SSCALED = 94,
432    VK_FORMAT_R16G16B16A16_UINT = 95,
433    VK_FORMAT_R16G16B16A16_SINT = 96,
434    VK_FORMAT_R16G16B16A16_SFLOAT = 97,
435    VK_FORMAT_R32_UINT = 98,
436    VK_FORMAT_R32_SINT = 99,
437    VK_FORMAT_R32_SFLOAT = 100,
438    VK_FORMAT_R32G32_UINT = 101,
439    VK_FORMAT_R32G32_SINT = 102,
440    VK_FORMAT_R32G32_SFLOAT = 103,
441    VK_FORMAT_R32G32B32_UINT = 104,
442    VK_FORMAT_R32G32B32_SINT = 105,
443    VK_FORMAT_R32G32B32_SFLOAT = 106,
444    VK_FORMAT_R32G32B32A32_UINT = 107,
445    VK_FORMAT_R32G32B32A32_SINT = 108,
446    VK_FORMAT_R32G32B32A32_SFLOAT = 109,
447    VK_FORMAT_R64_UINT = 110,
448    VK_FORMAT_R64_SINT = 111,
449    VK_FORMAT_R64_SFLOAT = 112,
450    VK_FORMAT_R64G64_UINT = 113,
451    VK_FORMAT_R64G64_SINT = 114,
452    VK_FORMAT_R64G64_SFLOAT = 115,
453    VK_FORMAT_R64G64B64_UINT = 116,
454    VK_FORMAT_R64G64B64_SINT = 117,
455    VK_FORMAT_R64G64B64_SFLOAT = 118,
456    VK_FORMAT_R64G64B64A64_UINT = 119,
457    VK_FORMAT_R64G64B64A64_SINT = 120,
458    VK_FORMAT_R64G64B64A64_SFLOAT = 121,
459    VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
460    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
461    VK_FORMAT_D16_UNORM = 124,
462    VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
463    VK_FORMAT_D32_SFLOAT = 126,
464    VK_FORMAT_S8_UINT = 127,
465    VK_FORMAT_D16_UNORM_S8_UINT = 128,
466    VK_FORMAT_D24_UNORM_S8_UINT = 129,
467    VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
468    VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
469    VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
470    VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
471    VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
472    VK_FORMAT_BC2_UNORM_BLOCK = 135,
473    VK_FORMAT_BC2_SRGB_BLOCK = 136,
474    VK_FORMAT_BC3_UNORM_BLOCK = 137,
475    VK_FORMAT_BC3_SRGB_BLOCK = 138,
476    VK_FORMAT_BC4_UNORM_BLOCK = 139,
477    VK_FORMAT_BC4_SNORM_BLOCK = 140,
478    VK_FORMAT_BC5_UNORM_BLOCK = 141,
479    VK_FORMAT_BC5_SNORM_BLOCK = 142,
480    VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
481    VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
482    VK_FORMAT_BC7_UNORM_BLOCK = 145,
483    VK_FORMAT_BC7_SRGB_BLOCK = 146,
484    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
485    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
486    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
487    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
488    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
489    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
490    VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
491    VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
492    VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
493    VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
494    VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
495    VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
496    VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
497    VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
498    VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
499    VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
500    VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
501    VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
502    VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
503    VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
504    VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
505    VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
506    VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
507    VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
508    VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
509    VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
510    VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
511    VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
512    VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
513    VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
514    VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
515    VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
516    VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
517    VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
518    VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
519    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
520    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
521    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
522    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
523    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
524    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
525    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
526    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
527    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
528    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
529    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
530    VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
531    VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
532    VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
533    VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
534} VkFormat;
535
536typedef enum VkImageType {
537    VK_IMAGE_TYPE_1D = 0,
538    VK_IMAGE_TYPE_2D = 1,
539    VK_IMAGE_TYPE_3D = 2,
540    VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
541    VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
542    VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
543    VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
544} VkImageType;
545
546typedef enum VkImageTiling {
547    VK_IMAGE_TILING_OPTIMAL = 0,
548    VK_IMAGE_TILING_LINEAR = 1,
549    VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
550    VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
551    VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
552    VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
553} VkImageTiling;
554
555typedef enum VkPhysicalDeviceType {
556    VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
557    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
558    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
559    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
560    VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
561    VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
562    VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
563    VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
564    VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
565} VkPhysicalDeviceType;
566
567typedef enum VkQueryType {
568    VK_QUERY_TYPE_OCCLUSION = 0,
569    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
570    VK_QUERY_TYPE_TIMESTAMP = 2,
571    VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
572    VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
573    VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
574    VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
575} VkQueryType;
576
577typedef enum VkSharingMode {
578    VK_SHARING_MODE_EXCLUSIVE = 0,
579    VK_SHARING_MODE_CONCURRENT = 1,
580    VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
581    VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
582    VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
583    VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
584} VkSharingMode;
585
586typedef enum VkImageLayout {
587    VK_IMAGE_LAYOUT_UNDEFINED = 0,
588    VK_IMAGE_LAYOUT_GENERAL = 1,
589    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
590    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
591    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
592    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
593    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
594    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
595    VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
596    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
597    VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
598    VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
599    VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
600    VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
601    VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
602} VkImageLayout;
603
604typedef enum VkImageViewType {
605    VK_IMAGE_VIEW_TYPE_1D = 0,
606    VK_IMAGE_VIEW_TYPE_2D = 1,
607    VK_IMAGE_VIEW_TYPE_3D = 2,
608    VK_IMAGE_VIEW_TYPE_CUBE = 3,
609    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
610    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
611    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
612    VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
613    VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
614    VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
615    VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
616} VkImageViewType;
617
618typedef enum VkComponentSwizzle {
619    VK_COMPONENT_SWIZZLE_IDENTITY = 0,
620    VK_COMPONENT_SWIZZLE_ZERO = 1,
621    VK_COMPONENT_SWIZZLE_ONE = 2,
622    VK_COMPONENT_SWIZZLE_R = 3,
623    VK_COMPONENT_SWIZZLE_G = 4,
624    VK_COMPONENT_SWIZZLE_B = 5,
625    VK_COMPONENT_SWIZZLE_A = 6,
626    VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
627    VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
628    VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
629    VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
630} VkComponentSwizzle;
631
632typedef enum VkVertexInputRate {
633    VK_VERTEX_INPUT_RATE_VERTEX = 0,
634    VK_VERTEX_INPUT_RATE_INSTANCE = 1,
635    VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
636    VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
637    VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
638    VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
639} VkVertexInputRate;
640
641typedef enum VkPrimitiveTopology {
642    VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
643    VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
644    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
645    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
646    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
647    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
648    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
649    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
650    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
651    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
652    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
653    VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
654    VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
655    VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
656    VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
657} VkPrimitiveTopology;
658
659typedef enum VkPolygonMode {
660    VK_POLYGON_MODE_FILL = 0,
661    VK_POLYGON_MODE_LINE = 1,
662    VK_POLYGON_MODE_POINT = 2,
663    VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
664    VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
665    VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
666    VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
667} VkPolygonMode;
668
669typedef enum VkFrontFace {
670    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
671    VK_FRONT_FACE_CLOCKWISE = 1,
672    VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
673    VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
674    VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
675    VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
676} VkFrontFace;
677
678typedef enum VkCompareOp {
679    VK_COMPARE_OP_NEVER = 0,
680    VK_COMPARE_OP_LESS = 1,
681    VK_COMPARE_OP_EQUAL = 2,
682    VK_COMPARE_OP_LESS_OR_EQUAL = 3,
683    VK_COMPARE_OP_GREATER = 4,
684    VK_COMPARE_OP_NOT_EQUAL = 5,
685    VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
686    VK_COMPARE_OP_ALWAYS = 7,
687    VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
688    VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
689    VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
690    VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
691} VkCompareOp;
692
693typedef enum VkStencilOp {
694    VK_STENCIL_OP_KEEP = 0,
695    VK_STENCIL_OP_ZERO = 1,
696    VK_STENCIL_OP_REPLACE = 2,
697    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
698    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
699    VK_STENCIL_OP_INVERT = 5,
700    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
701    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
702    VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
703    VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
704    VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
705    VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
706} VkStencilOp;
707
708typedef enum VkLogicOp {
709    VK_LOGIC_OP_CLEAR = 0,
710    VK_LOGIC_OP_AND = 1,
711    VK_LOGIC_OP_AND_REVERSE = 2,
712    VK_LOGIC_OP_COPY = 3,
713    VK_LOGIC_OP_AND_INVERTED = 4,
714    VK_LOGIC_OP_NO_OP = 5,
715    VK_LOGIC_OP_XOR = 6,
716    VK_LOGIC_OP_OR = 7,
717    VK_LOGIC_OP_NOR = 8,
718    VK_LOGIC_OP_EQUIVALENT = 9,
719    VK_LOGIC_OP_INVERT = 10,
720    VK_LOGIC_OP_OR_REVERSE = 11,
721    VK_LOGIC_OP_COPY_INVERTED = 12,
722    VK_LOGIC_OP_OR_INVERTED = 13,
723    VK_LOGIC_OP_NAND = 14,
724    VK_LOGIC_OP_SET = 15,
725    VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
726    VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
727    VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
728    VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
729} VkLogicOp;
730
731typedef enum VkBlendFactor {
732    VK_BLEND_FACTOR_ZERO = 0,
733    VK_BLEND_FACTOR_ONE = 1,
734    VK_BLEND_FACTOR_SRC_COLOR = 2,
735    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
736    VK_BLEND_FACTOR_DST_COLOR = 4,
737    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
738    VK_BLEND_FACTOR_SRC_ALPHA = 6,
739    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
740    VK_BLEND_FACTOR_DST_ALPHA = 8,
741    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
742    VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
743    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
744    VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
745    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
746    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
747    VK_BLEND_FACTOR_SRC1_COLOR = 15,
748    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
749    VK_BLEND_FACTOR_SRC1_ALPHA = 17,
750    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
751    VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
752    VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
753    VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
754    VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
755} VkBlendFactor;
756
757typedef enum VkBlendOp {
758    VK_BLEND_OP_ADD = 0,
759    VK_BLEND_OP_SUBTRACT = 1,
760    VK_BLEND_OP_REVERSE_SUBTRACT = 2,
761    VK_BLEND_OP_MIN = 3,
762    VK_BLEND_OP_MAX = 4,
763    VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
764    VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
765    VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
766    VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
767} VkBlendOp;
768
769typedef enum VkDynamicState {
770    VK_DYNAMIC_STATE_VIEWPORT = 0,
771    VK_DYNAMIC_STATE_SCISSOR = 1,
772    VK_DYNAMIC_STATE_LINE_WIDTH = 2,
773    VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
774    VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
775    VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
776    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
777    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
778    VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
779    VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
780    VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
781    VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
782    VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
783    VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
784    VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
785} VkDynamicState;
786
787typedef enum VkFilter {
788    VK_FILTER_NEAREST = 0,
789    VK_FILTER_LINEAR = 1,
790    VK_FILTER_CUBIC_IMG = 1000015000,
791    VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
792    VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
793    VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
794    VK_FILTER_MAX_ENUM = 0x7FFFFFFF
795} VkFilter;
796
797typedef enum VkSamplerMipmapMode {
798    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
799    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
800    VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
801    VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
802    VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
803    VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
804} VkSamplerMipmapMode;
805
806typedef enum VkSamplerAddressMode {
807    VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
808    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
809    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
810    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
811    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
812    VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
813    VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
814    VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
815    VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
816} VkSamplerAddressMode;
817
818typedef enum VkBorderColor {
819    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
820    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
821    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
822    VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
823    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
824    VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
825    VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
826    VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
827    VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
828    VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
829} VkBorderColor;
830
831typedef enum VkDescriptorType {
832    VK_DESCRIPTOR_TYPE_SAMPLER = 0,
833    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
834    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
835    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
836    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
837    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
838    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
839    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
840    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
841    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
842    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
843    VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
844    VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
845    VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
846    VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
847} VkDescriptorType;
848
849typedef enum VkAttachmentLoadOp {
850    VK_ATTACHMENT_LOAD_OP_LOAD = 0,
851    VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
852    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
853    VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
854    VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
855    VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
856    VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
857} VkAttachmentLoadOp;
858
859typedef enum VkAttachmentStoreOp {
860    VK_ATTACHMENT_STORE_OP_STORE = 0,
861    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
862    VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
863    VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
864    VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
865    VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
866} VkAttachmentStoreOp;
867
868typedef enum VkPipelineBindPoint {
869    VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
870    VK_PIPELINE_BIND_POINT_COMPUTE = 1,
871    VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
872    VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
873    VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
874    VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
875} VkPipelineBindPoint;
876
877typedef enum VkCommandBufferLevel {
878    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
879    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
880    VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
881    VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
882    VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
883    VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
884} VkCommandBufferLevel;
885
886typedef enum VkIndexType {
887    VK_INDEX_TYPE_UINT16 = 0,
888    VK_INDEX_TYPE_UINT32 = 1,
889    VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
890    VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
891    VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
892    VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
893} VkIndexType;
894
895typedef enum VkSubpassContents {
896    VK_SUBPASS_CONTENTS_INLINE = 0,
897    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
898    VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
899    VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
900    VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
901    VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
902} VkSubpassContents;
903
904typedef VkFlags VkInstanceCreateFlags;
905
906typedef enum VkFormatFeatureFlagBits {
907    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
908    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
909    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
910    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
911    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
912    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
913    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
914    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
915    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
916    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
917    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
918    VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
919    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
920    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
921    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
922    VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
923    VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
924} VkFormatFeatureFlagBits;
925typedef VkFlags VkFormatFeatureFlags;
926
927typedef enum VkImageUsageFlagBits {
928    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
929    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
930    VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
931    VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
932    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
933    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
934    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
935    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
936    VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
937} VkImageUsageFlagBits;
938typedef VkFlags VkImageUsageFlags;
939
940typedef enum VkImageCreateFlagBits {
941    VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
942    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
943    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
944    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
945    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
946    VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040,
947    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020,
948    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
949} VkImageCreateFlagBits;
950typedef VkFlags VkImageCreateFlags;
951
952typedef enum VkSampleCountFlagBits {
953    VK_SAMPLE_COUNT_1_BIT = 0x00000001,
954    VK_SAMPLE_COUNT_2_BIT = 0x00000002,
955    VK_SAMPLE_COUNT_4_BIT = 0x00000004,
956    VK_SAMPLE_COUNT_8_BIT = 0x00000008,
957    VK_SAMPLE_COUNT_16_BIT = 0x00000010,
958    VK_SAMPLE_COUNT_32_BIT = 0x00000020,
959    VK_SAMPLE_COUNT_64_BIT = 0x00000040,
960    VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
961} VkSampleCountFlagBits;
962typedef VkFlags VkSampleCountFlags;
963
964typedef enum VkQueueFlagBits {
965    VK_QUEUE_GRAPHICS_BIT = 0x00000001,
966    VK_QUEUE_COMPUTE_BIT = 0x00000002,
967    VK_QUEUE_TRANSFER_BIT = 0x00000004,
968    VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
969    VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
970} VkQueueFlagBits;
971typedef VkFlags VkQueueFlags;
972
973typedef enum VkMemoryPropertyFlagBits {
974    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
975    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
976    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
977    VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
978    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
979    VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
980} VkMemoryPropertyFlagBits;
981typedef VkFlags VkMemoryPropertyFlags;
982
983typedef enum VkMemoryHeapFlagBits {
984    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
985    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002,
986    VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
987} VkMemoryHeapFlagBits;
988typedef VkFlags VkMemoryHeapFlags;
989typedef VkFlags VkDeviceCreateFlags;
990typedef VkFlags VkDeviceQueueCreateFlags;
991
992typedef enum VkPipelineStageFlagBits {
993    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
994    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
995    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
996    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
997    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
998    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
999    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
1000    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
1001    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
1002    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
1003    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
1004    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
1005    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
1006    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
1007    VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
1008    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
1009    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
1010    VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
1011    VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1012} VkPipelineStageFlagBits;
1013typedef VkFlags VkPipelineStageFlags;
1014typedef VkFlags VkMemoryMapFlags;
1015
1016typedef enum VkImageAspectFlagBits {
1017    VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
1018    VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
1019    VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
1020    VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
1021    VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1022} VkImageAspectFlagBits;
1023typedef VkFlags VkImageAspectFlags;
1024
1025typedef enum VkSparseImageFormatFlagBits {
1026    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
1027    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
1028    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
1029    VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1030} VkSparseImageFormatFlagBits;
1031typedef VkFlags VkSparseImageFormatFlags;
1032
1033typedef enum VkSparseMemoryBindFlagBits {
1034    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
1035    VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1036} VkSparseMemoryBindFlagBits;
1037typedef VkFlags VkSparseMemoryBindFlags;
1038
1039typedef enum VkFenceCreateFlagBits {
1040    VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
1041    VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1042} VkFenceCreateFlagBits;
1043typedef VkFlags VkFenceCreateFlags;
1044typedef VkFlags VkSemaphoreCreateFlags;
1045typedef VkFlags VkEventCreateFlags;
1046typedef VkFlags VkQueryPoolCreateFlags;
1047
1048typedef enum VkQueryPipelineStatisticFlagBits {
1049    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
1050    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
1051    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
1052    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
1053    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
1054    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
1055    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
1056    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
1057    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
1058    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
1059    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
1060    VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1061} VkQueryPipelineStatisticFlagBits;
1062typedef VkFlags VkQueryPipelineStatisticFlags;
1063
1064typedef enum VkQueryResultFlagBits {
1065    VK_QUERY_RESULT_64_BIT = 0x00000001,
1066    VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
1067    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
1068    VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
1069    VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1070} VkQueryResultFlagBits;
1071typedef VkFlags VkQueryResultFlags;
1072
1073typedef enum VkBufferCreateFlagBits {
1074    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
1075    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
1076    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
1077    VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1078} VkBufferCreateFlagBits;
1079typedef VkFlags VkBufferCreateFlags;
1080
1081typedef enum VkBufferUsageFlagBits {
1082    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
1083    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
1084    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
1085    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
1086    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
1087    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
1088    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
1089    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
1090    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
1091    VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1092} VkBufferUsageFlagBits;
1093typedef VkFlags VkBufferUsageFlags;
1094typedef VkFlags VkBufferViewCreateFlags;
1095typedef VkFlags VkImageViewCreateFlags;
1096typedef VkFlags VkShaderModuleCreateFlags;
1097typedef VkFlags VkPipelineCacheCreateFlags;
1098
1099typedef enum VkPipelineCreateFlagBits {
1100    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
1101    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
1102    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
1103    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008,
1104    VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010,
1105    VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1106} VkPipelineCreateFlagBits;
1107typedef VkFlags VkPipelineCreateFlags;
1108typedef VkFlags VkPipelineShaderStageCreateFlags;
1109
1110typedef enum VkShaderStageFlagBits {
1111    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
1112    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
1113    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
1114    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
1115    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
1116    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
1117    VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
1118    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
1119    VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1120} VkShaderStageFlagBits;
1121typedef VkFlags VkPipelineVertexInputStateCreateFlags;
1122typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
1123typedef VkFlags VkPipelineTessellationStateCreateFlags;
1124typedef VkFlags VkPipelineViewportStateCreateFlags;
1125typedef VkFlags VkPipelineRasterizationStateCreateFlags;
1126
1127typedef enum VkCullModeFlagBits {
1128    VK_CULL_MODE_NONE = 0,
1129    VK_CULL_MODE_FRONT_BIT = 0x00000001,
1130    VK_CULL_MODE_BACK_BIT = 0x00000002,
1131    VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
1132    VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1133} VkCullModeFlagBits;
1134typedef VkFlags VkCullModeFlags;
1135typedef VkFlags VkPipelineMultisampleStateCreateFlags;
1136typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
1137typedef VkFlags VkPipelineColorBlendStateCreateFlags;
1138
1139typedef enum VkColorComponentFlagBits {
1140    VK_COLOR_COMPONENT_R_BIT = 0x00000001,
1141    VK_COLOR_COMPONENT_G_BIT = 0x00000002,
1142    VK_COLOR_COMPONENT_B_BIT = 0x00000004,
1143    VK_COLOR_COMPONENT_A_BIT = 0x00000008,
1144    VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1145} VkColorComponentFlagBits;
1146typedef VkFlags VkColorComponentFlags;
1147typedef VkFlags VkPipelineDynamicStateCreateFlags;
1148typedef VkFlags VkPipelineLayoutCreateFlags;
1149typedef VkFlags VkShaderStageFlags;
1150typedef VkFlags VkSamplerCreateFlags;
1151
1152typedef enum VkDescriptorSetLayoutCreateFlagBits {
1153    VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
1154    VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1155} VkDescriptorSetLayoutCreateFlagBits;
1156typedef VkFlags VkDescriptorSetLayoutCreateFlags;
1157
1158typedef enum VkDescriptorPoolCreateFlagBits {
1159    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
1160    VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1161} VkDescriptorPoolCreateFlagBits;
1162typedef VkFlags VkDescriptorPoolCreateFlags;
1163typedef VkFlags VkDescriptorPoolResetFlags;
1164typedef VkFlags VkFramebufferCreateFlags;
1165typedef VkFlags VkRenderPassCreateFlags;
1166
1167typedef enum VkAttachmentDescriptionFlagBits {
1168    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
1169    VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1170} VkAttachmentDescriptionFlagBits;
1171typedef VkFlags VkAttachmentDescriptionFlags;
1172
1173typedef enum VkSubpassDescriptionFlagBits {
1174    VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
1175    VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
1176    VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1177} VkSubpassDescriptionFlagBits;
1178typedef VkFlags VkSubpassDescriptionFlags;
1179
1180typedef enum VkAccessFlagBits {
1181    VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
1182    VK_ACCESS_INDEX_READ_BIT = 0x00000002,
1183    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
1184    VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
1185    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
1186    VK_ACCESS_SHADER_READ_BIT = 0x00000020,
1187    VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
1188    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
1189    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
1190    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
1191    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
1192    VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
1193    VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
1194    VK_ACCESS_HOST_READ_BIT = 0x00002000,
1195    VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
1196    VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
1197    VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
1198    VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
1199    VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
1200    VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1201} VkAccessFlagBits;
1202typedef VkFlags VkAccessFlags;
1203
1204typedef enum VkDependencyFlagBits {
1205    VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
1206    VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002,
1207    VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004,
1208    VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1209} VkDependencyFlagBits;
1210typedef VkFlags VkDependencyFlags;
1211
1212typedef enum VkCommandPoolCreateFlagBits {
1213    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
1214    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
1215    VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1216} VkCommandPoolCreateFlagBits;
1217typedef VkFlags VkCommandPoolCreateFlags;
1218
1219typedef enum VkCommandPoolResetFlagBits {
1220    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1221    VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1222} VkCommandPoolResetFlagBits;
1223typedef VkFlags VkCommandPoolResetFlags;
1224
1225typedef enum VkCommandBufferUsageFlagBits {
1226    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
1227    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
1228    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
1229    VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1230} VkCommandBufferUsageFlagBits;
1231typedef VkFlags VkCommandBufferUsageFlags;
1232
1233typedef enum VkQueryControlFlagBits {
1234    VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
1235    VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1236} VkQueryControlFlagBits;
1237typedef VkFlags VkQueryControlFlags;
1238
1239typedef enum VkCommandBufferResetFlagBits {
1240    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
1241    VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1242} VkCommandBufferResetFlagBits;
1243typedef VkFlags VkCommandBufferResetFlags;
1244
1245typedef enum VkStencilFaceFlagBits {
1246    VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
1247    VK_STENCIL_FACE_BACK_BIT = 0x00000002,
1248    VK_STENCIL_FRONT_AND_BACK = 0x00000003,
1249    VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
1250} VkStencilFaceFlagBits;
1251typedef VkFlags VkStencilFaceFlags;
1252
1253typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
1254    void*                                       pUserData,
1255    size_t                                      size,
1256    size_t                                      alignment,
1257    VkSystemAllocationScope                     allocationScope);
1258
1259typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
1260    void*                                       pUserData,
1261    void*                                       pOriginal,
1262    size_t                                      size,
1263    size_t                                      alignment,
1264    VkSystemAllocationScope                     allocationScope);
1265
1266typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
1267    void*                                       pUserData,
1268    void*                                       pMemory);
1269
1270typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
1271    void*                                       pUserData,
1272    size_t                                      size,
1273    VkInternalAllocationType                    allocationType,
1274    VkSystemAllocationScope                     allocationScope);
1275
1276typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
1277    void*                                       pUserData,
1278    size_t                                      size,
1279    VkInternalAllocationType                    allocationType,
1280    VkSystemAllocationScope                     allocationScope);
1281
1282typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
1283
1284typedef struct VkApplicationInfo {
1285    VkStructureType    sType;
1286    const void*        pNext;
1287    const char*        pApplicationName;
1288    uint32_t           applicationVersion;
1289    const char*        pEngineName;
1290    uint32_t           engineVersion;
1291    uint32_t           apiVersion;
1292} VkApplicationInfo;
1293
1294typedef struct VkInstanceCreateInfo {
1295    VkStructureType             sType;
1296    const void*                 pNext;
1297    VkInstanceCreateFlags       flags;
1298    const VkApplicationInfo*    pApplicationInfo;
1299    uint32_t                    enabledLayerCount;
1300    const char* const*          ppEnabledLayerNames;
1301    uint32_t                    enabledExtensionCount;
1302    const char* const*          ppEnabledExtensionNames;
1303} VkInstanceCreateInfo;
1304
1305typedef struct VkAllocationCallbacks {
1306    void*                                   pUserData;
1307    PFN_vkAllocationFunction                pfnAllocation;
1308    PFN_vkReallocationFunction              pfnReallocation;
1309    PFN_vkFreeFunction                      pfnFree;
1310    PFN_vkInternalAllocationNotification    pfnInternalAllocation;
1311    PFN_vkInternalFreeNotification          pfnInternalFree;
1312} VkAllocationCallbacks;
1313
1314typedef struct VkPhysicalDeviceFeatures {
1315    VkBool32    robustBufferAccess;
1316    VkBool32    fullDrawIndexUint32;
1317    VkBool32    imageCubeArray;
1318    VkBool32    independentBlend;
1319    VkBool32    geometryShader;
1320    VkBool32    tessellationShader;
1321    VkBool32    sampleRateShading;
1322    VkBool32    dualSrcBlend;
1323    VkBool32    logicOp;
1324    VkBool32    multiDrawIndirect;
1325    VkBool32    drawIndirectFirstInstance;
1326    VkBool32    depthClamp;
1327    VkBool32    depthBiasClamp;
1328    VkBool32    fillModeNonSolid;
1329    VkBool32    depthBounds;
1330    VkBool32    wideLines;
1331    VkBool32    largePoints;
1332    VkBool32    alphaToOne;
1333    VkBool32    multiViewport;
1334    VkBool32    samplerAnisotropy;
1335    VkBool32    textureCompressionETC2;
1336    VkBool32    textureCompressionASTC_LDR;
1337    VkBool32    textureCompressionBC;
1338    VkBool32    occlusionQueryPrecise;
1339    VkBool32    pipelineStatisticsQuery;
1340    VkBool32    vertexPipelineStoresAndAtomics;
1341    VkBool32    fragmentStoresAndAtomics;
1342    VkBool32    shaderTessellationAndGeometryPointSize;
1343    VkBool32    shaderImageGatherExtended;
1344    VkBool32    shaderStorageImageExtendedFormats;
1345    VkBool32    shaderStorageImageMultisample;
1346    VkBool32    shaderStorageImageReadWithoutFormat;
1347    VkBool32    shaderStorageImageWriteWithoutFormat;
1348    VkBool32    shaderUniformBufferArrayDynamicIndexing;
1349    VkBool32    shaderSampledImageArrayDynamicIndexing;
1350    VkBool32    shaderStorageBufferArrayDynamicIndexing;
1351    VkBool32    shaderStorageImageArrayDynamicIndexing;
1352    VkBool32    shaderClipDistance;
1353    VkBool32    shaderCullDistance;
1354    VkBool32    shaderFloat64;
1355    VkBool32    shaderInt64;
1356    VkBool32    shaderInt16;
1357    VkBool32    shaderResourceResidency;
1358    VkBool32    shaderResourceMinLod;
1359    VkBool32    sparseBinding;
1360    VkBool32    sparseResidencyBuffer;
1361    VkBool32    sparseResidencyImage2D;
1362    VkBool32    sparseResidencyImage3D;
1363    VkBool32    sparseResidency2Samples;
1364    VkBool32    sparseResidency4Samples;
1365    VkBool32    sparseResidency8Samples;
1366    VkBool32    sparseResidency16Samples;
1367    VkBool32    sparseResidencyAliased;
1368    VkBool32    variableMultisampleRate;
1369    VkBool32    inheritedQueries;
1370} VkPhysicalDeviceFeatures;
1371
1372typedef struct VkFormatProperties {
1373    VkFormatFeatureFlags    linearTilingFeatures;
1374    VkFormatFeatureFlags    optimalTilingFeatures;
1375    VkFormatFeatureFlags    bufferFeatures;
1376} VkFormatProperties;
1377
1378typedef struct VkExtent3D {
1379    uint32_t    width;
1380    uint32_t    height;
1381    uint32_t    depth;
1382} VkExtent3D;
1383
1384typedef struct VkImageFormatProperties {
1385    VkExtent3D            maxExtent;
1386    uint32_t              maxMipLevels;
1387    uint32_t              maxArrayLayers;
1388    VkSampleCountFlags    sampleCounts;
1389    VkDeviceSize          maxResourceSize;
1390} VkImageFormatProperties;
1391
1392typedef struct VkPhysicalDeviceLimits {
1393    uint32_t              maxImageDimension1D;
1394    uint32_t              maxImageDimension2D;
1395    uint32_t              maxImageDimension3D;
1396    uint32_t              maxImageDimensionCube;
1397    uint32_t              maxImageArrayLayers;
1398    uint32_t              maxTexelBufferElements;
1399    uint32_t              maxUniformBufferRange;
1400    uint32_t              maxStorageBufferRange;
1401    uint32_t              maxPushConstantsSize;
1402    uint32_t              maxMemoryAllocationCount;
1403    uint32_t              maxSamplerAllocationCount;
1404    VkDeviceSize          bufferImageGranularity;
1405    VkDeviceSize          sparseAddressSpaceSize;
1406    uint32_t              maxBoundDescriptorSets;
1407    uint32_t              maxPerStageDescriptorSamplers;
1408    uint32_t              maxPerStageDescriptorUniformBuffers;
1409    uint32_t              maxPerStageDescriptorStorageBuffers;
1410    uint32_t              maxPerStageDescriptorSampledImages;
1411    uint32_t              maxPerStageDescriptorStorageImages;
1412    uint32_t              maxPerStageDescriptorInputAttachments;
1413    uint32_t              maxPerStageResources;
1414    uint32_t              maxDescriptorSetSamplers;
1415    uint32_t              maxDescriptorSetUniformBuffers;
1416    uint32_t              maxDescriptorSetUniformBuffersDynamic;
1417    uint32_t              maxDescriptorSetStorageBuffers;
1418    uint32_t              maxDescriptorSetStorageBuffersDynamic;
1419    uint32_t              maxDescriptorSetSampledImages;
1420    uint32_t              maxDescriptorSetStorageImages;
1421    uint32_t              maxDescriptorSetInputAttachments;
1422    uint32_t              maxVertexInputAttributes;
1423    uint32_t              maxVertexInputBindings;
1424    uint32_t              maxVertexInputAttributeOffset;
1425    uint32_t              maxVertexInputBindingStride;
1426    uint32_t              maxVertexOutputComponents;
1427    uint32_t              maxTessellationGenerationLevel;
1428    uint32_t              maxTessellationPatchSize;
1429    uint32_t              maxTessellationControlPerVertexInputComponents;
1430    uint32_t              maxTessellationControlPerVertexOutputComponents;
1431    uint32_t              maxTessellationControlPerPatchOutputComponents;
1432    uint32_t              maxTessellationControlTotalOutputComponents;
1433    uint32_t              maxTessellationEvaluationInputComponents;
1434    uint32_t              maxTessellationEvaluationOutputComponents;
1435    uint32_t              maxGeometryShaderInvocations;
1436    uint32_t              maxGeometryInputComponents;
1437    uint32_t              maxGeometryOutputComponents;
1438    uint32_t              maxGeometryOutputVertices;
1439    uint32_t              maxGeometryTotalOutputComponents;
1440    uint32_t              maxFragmentInputComponents;
1441    uint32_t              maxFragmentOutputAttachments;
1442    uint32_t              maxFragmentDualSrcAttachments;
1443    uint32_t              maxFragmentCombinedOutputResources;
1444    uint32_t              maxComputeSharedMemorySize;
1445    uint32_t              maxComputeWorkGroupCount[3];
1446    uint32_t              maxComputeWorkGroupInvocations;
1447    uint32_t              maxComputeWorkGroupSize[3];
1448    uint32_t              subPixelPrecisionBits;
1449    uint32_t              subTexelPrecisionBits;
1450    uint32_t              mipmapPrecisionBits;
1451    uint32_t              maxDrawIndexedIndexValue;
1452    uint32_t              maxDrawIndirectCount;
1453    float                 maxSamplerLodBias;
1454    float                 maxSamplerAnisotropy;
1455    uint32_t              maxViewports;
1456    uint32_t              maxViewportDimensions[2];
1457    float                 viewportBoundsRange[2];
1458    uint32_t              viewportSubPixelBits;
1459    size_t                minMemoryMapAlignment;
1460    VkDeviceSize          minTexelBufferOffsetAlignment;
1461    VkDeviceSize          minUniformBufferOffsetAlignment;
1462    VkDeviceSize          minStorageBufferOffsetAlignment;
1463    int32_t               minTexelOffset;
1464    uint32_t              maxTexelOffset;
1465    int32_t               minTexelGatherOffset;
1466    uint32_t              maxTexelGatherOffset;
1467    float                 minInterpolationOffset;
1468    float                 maxInterpolationOffset;
1469    uint32_t              subPixelInterpolationOffsetBits;
1470    uint32_t              maxFramebufferWidth;
1471    uint32_t              maxFramebufferHeight;
1472    uint32_t              maxFramebufferLayers;
1473    VkSampleCountFlags    framebufferColorSampleCounts;
1474    VkSampleCountFlags    framebufferDepthSampleCounts;
1475    VkSampleCountFlags    framebufferStencilSampleCounts;
1476    VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
1477    uint32_t              maxColorAttachments;
1478    VkSampleCountFlags    sampledImageColorSampleCounts;
1479    VkSampleCountFlags    sampledImageIntegerSampleCounts;
1480    VkSampleCountFlags    sampledImageDepthSampleCounts;
1481    VkSampleCountFlags    sampledImageStencilSampleCounts;
1482    VkSampleCountFlags    storageImageSampleCounts;
1483    uint32_t              maxSampleMaskWords;
1484    VkBool32              timestampComputeAndGraphics;
1485    float                 timestampPeriod;
1486    uint32_t              maxClipDistances;
1487    uint32_t              maxCullDistances;
1488    uint32_t              maxCombinedClipAndCullDistances;
1489    uint32_t              discreteQueuePriorities;
1490    float                 pointSizeRange[2];
1491    float                 lineWidthRange[2];
1492    float                 pointSizeGranularity;
1493    float                 lineWidthGranularity;
1494    VkBool32              strictLines;
1495    VkBool32              standardSampleLocations;
1496    VkDeviceSize          optimalBufferCopyOffsetAlignment;
1497    VkDeviceSize          optimalBufferCopyRowPitchAlignment;
1498    VkDeviceSize          nonCoherentAtomSize;
1499} VkPhysicalDeviceLimits;
1500
1501typedef struct VkPhysicalDeviceSparseProperties {
1502    VkBool32    residencyStandard2DBlockShape;
1503    VkBool32    residencyStandard2DMultisampleBlockShape;
1504    VkBool32    residencyStandard3DBlockShape;
1505    VkBool32    residencyAlignedMipSize;
1506    VkBool32    residencyNonResidentStrict;
1507} VkPhysicalDeviceSparseProperties;
1508
1509typedef struct VkPhysicalDeviceProperties {
1510    uint32_t                            apiVersion;
1511    uint32_t                            driverVersion;
1512    uint32_t                            vendorID;
1513    uint32_t                            deviceID;
1514    VkPhysicalDeviceType                deviceType;
1515    char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
1516    uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
1517    VkPhysicalDeviceLimits              limits;
1518    VkPhysicalDeviceSparseProperties    sparseProperties;
1519} VkPhysicalDeviceProperties;
1520
1521typedef struct VkQueueFamilyProperties {
1522    VkQueueFlags    queueFlags;
1523    uint32_t        queueCount;
1524    uint32_t        timestampValidBits;
1525    VkExtent3D      minImageTransferGranularity;
1526} VkQueueFamilyProperties;
1527
1528typedef struct VkMemoryType {
1529    VkMemoryPropertyFlags    propertyFlags;
1530    uint32_t                 heapIndex;
1531} VkMemoryType;
1532
1533typedef struct VkMemoryHeap {
1534    VkDeviceSize         size;
1535    VkMemoryHeapFlags    flags;
1536} VkMemoryHeap;
1537
1538typedef struct VkPhysicalDeviceMemoryProperties {
1539    uint32_t        memoryTypeCount;
1540    VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
1541    uint32_t        memoryHeapCount;
1542    VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
1543} VkPhysicalDeviceMemoryProperties;
1544
1545typedef struct VkDeviceQueueCreateInfo {
1546    VkStructureType             sType;
1547    const void*                 pNext;
1548    VkDeviceQueueCreateFlags    flags;
1549    uint32_t                    queueFamilyIndex;
1550    uint32_t                    queueCount;
1551    const float*                pQueuePriorities;
1552} VkDeviceQueueCreateInfo;
1553
1554typedef struct VkDeviceCreateInfo {
1555    VkStructureType                    sType;
1556    const void*                        pNext;
1557    VkDeviceCreateFlags                flags;
1558    uint32_t                           queueCreateInfoCount;
1559    const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
1560    uint32_t                           enabledLayerCount;
1561    const char* const*                 ppEnabledLayerNames;
1562    uint32_t                           enabledExtensionCount;
1563    const char* const*                 ppEnabledExtensionNames;
1564    const VkPhysicalDeviceFeatures*    pEnabledFeatures;
1565} VkDeviceCreateInfo;
1566
1567typedef struct VkExtensionProperties {
1568    char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
1569    uint32_t    specVersion;
1570} VkExtensionProperties;
1571
1572typedef struct VkLayerProperties {
1573    char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
1574    uint32_t    specVersion;
1575    uint32_t    implementationVersion;
1576    char        description[VK_MAX_DESCRIPTION_SIZE];
1577} VkLayerProperties;
1578
1579typedef struct VkSubmitInfo {
1580    VkStructureType                sType;
1581    const void*                    pNext;
1582    uint32_t                       waitSemaphoreCount;
1583    const VkSemaphore*             pWaitSemaphores;
1584    const VkPipelineStageFlags*    pWaitDstStageMask;
1585    uint32_t                       commandBufferCount;
1586    const VkCommandBuffer*         pCommandBuffers;
1587    uint32_t                       signalSemaphoreCount;
1588    const VkSemaphore*             pSignalSemaphores;
1589} VkSubmitInfo;
1590
1591typedef struct VkMemoryAllocateInfo {
1592    VkStructureType    sType;
1593    const void*        pNext;
1594    VkDeviceSize       allocationSize;
1595    uint32_t           memoryTypeIndex;
1596} VkMemoryAllocateInfo;
1597
1598typedef struct VkMappedMemoryRange {
1599    VkStructureType    sType;
1600    const void*        pNext;
1601    VkDeviceMemory     memory;
1602    VkDeviceSize       offset;
1603    VkDeviceSize       size;
1604} VkMappedMemoryRange;
1605
1606typedef struct VkMemoryRequirements {
1607    VkDeviceSize    size;
1608    VkDeviceSize    alignment;
1609    uint32_t        memoryTypeBits;
1610} VkMemoryRequirements;
1611
1612typedef struct VkSparseImageFormatProperties {
1613    VkImageAspectFlags          aspectMask;
1614    VkExtent3D                  imageGranularity;
1615    VkSparseImageFormatFlags    flags;
1616} VkSparseImageFormatProperties;
1617
1618typedef struct VkSparseImageMemoryRequirements {
1619    VkSparseImageFormatProperties    formatProperties;
1620    uint32_t                         imageMipTailFirstLod;
1621    VkDeviceSize                     imageMipTailSize;
1622    VkDeviceSize                     imageMipTailOffset;
1623    VkDeviceSize                     imageMipTailStride;
1624} VkSparseImageMemoryRequirements;
1625
1626typedef struct VkSparseMemoryBind {
1627    VkDeviceSize               resourceOffset;
1628    VkDeviceSize               size;
1629    VkDeviceMemory             memory;
1630    VkDeviceSize               memoryOffset;
1631    VkSparseMemoryBindFlags    flags;
1632} VkSparseMemoryBind;
1633
1634typedef struct VkSparseBufferMemoryBindInfo {
1635    VkBuffer                     buffer;
1636    uint32_t                     bindCount;
1637    const VkSparseMemoryBind*    pBinds;
1638} VkSparseBufferMemoryBindInfo;
1639
1640typedef struct VkSparseImageOpaqueMemoryBindInfo {
1641    VkImage                      image;
1642    uint32_t                     bindCount;
1643    const VkSparseMemoryBind*    pBinds;
1644} VkSparseImageOpaqueMemoryBindInfo;
1645
1646typedef struct VkImageSubresource {
1647    VkImageAspectFlags    aspectMask;
1648    uint32_t              mipLevel;
1649    uint32_t              arrayLayer;
1650} VkImageSubresource;
1651
1652typedef struct VkOffset3D {
1653    int32_t    x;
1654    int32_t    y;
1655    int32_t    z;
1656} VkOffset3D;
1657
1658typedef struct VkSparseImageMemoryBind {
1659    VkImageSubresource         subresource;
1660    VkOffset3D                 offset;
1661    VkExtent3D                 extent;
1662    VkDeviceMemory             memory;
1663    VkDeviceSize               memoryOffset;
1664    VkSparseMemoryBindFlags    flags;
1665} VkSparseImageMemoryBind;
1666
1667typedef struct VkSparseImageMemoryBindInfo {
1668    VkImage                           image;
1669    uint32_t                          bindCount;
1670    const VkSparseImageMemoryBind*    pBinds;
1671} VkSparseImageMemoryBindInfo;
1672
1673typedef struct VkBindSparseInfo {
1674    VkStructureType                             sType;
1675    const void*                                 pNext;
1676    uint32_t                                    waitSemaphoreCount;
1677    const VkSemaphore*                          pWaitSemaphores;
1678    uint32_t                                    bufferBindCount;
1679    const VkSparseBufferMemoryBindInfo*         pBufferBinds;
1680    uint32_t                                    imageOpaqueBindCount;
1681    const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
1682    uint32_t                                    imageBindCount;
1683    const VkSparseImageMemoryBindInfo*          pImageBinds;
1684    uint32_t                                    signalSemaphoreCount;
1685    const VkSemaphore*                          pSignalSemaphores;
1686} VkBindSparseInfo;
1687
1688typedef struct VkFenceCreateInfo {
1689    VkStructureType       sType;
1690    const void*           pNext;
1691    VkFenceCreateFlags    flags;
1692} VkFenceCreateInfo;
1693
1694typedef struct VkSemaphoreCreateInfo {
1695    VkStructureType           sType;
1696    const void*               pNext;
1697    VkSemaphoreCreateFlags    flags;
1698} VkSemaphoreCreateInfo;
1699
1700typedef struct VkEventCreateInfo {
1701    VkStructureType       sType;
1702    const void*           pNext;
1703    VkEventCreateFlags    flags;
1704} VkEventCreateInfo;
1705
1706typedef struct VkQueryPoolCreateInfo {
1707    VkStructureType                  sType;
1708    const void*                      pNext;
1709    VkQueryPoolCreateFlags           flags;
1710    VkQueryType                      queryType;
1711    uint32_t                         queryCount;
1712    VkQueryPipelineStatisticFlags    pipelineStatistics;
1713} VkQueryPoolCreateInfo;
1714
1715typedef struct VkBufferCreateInfo {
1716    VkStructureType        sType;
1717    const void*            pNext;
1718    VkBufferCreateFlags    flags;
1719    VkDeviceSize           size;
1720    VkBufferUsageFlags     usage;
1721    VkSharingMode          sharingMode;
1722    uint32_t               queueFamilyIndexCount;
1723    const uint32_t*        pQueueFamilyIndices;
1724} VkBufferCreateInfo;
1725
1726typedef struct VkBufferViewCreateInfo {
1727    VkStructureType            sType;
1728    const void*                pNext;
1729    VkBufferViewCreateFlags    flags;
1730    VkBuffer                   buffer;
1731    VkFormat                   format;
1732    VkDeviceSize               offset;
1733    VkDeviceSize               range;
1734} VkBufferViewCreateInfo;
1735
1736typedef struct VkImageCreateInfo {
1737    VkStructureType          sType;
1738    const void*              pNext;
1739    VkImageCreateFlags       flags;
1740    VkImageType              imageType;
1741    VkFormat                 format;
1742    VkExtent3D               extent;
1743    uint32_t                 mipLevels;
1744    uint32_t                 arrayLayers;
1745    VkSampleCountFlagBits    samples;
1746    VkImageTiling            tiling;
1747    VkImageUsageFlags        usage;
1748    VkSharingMode            sharingMode;
1749    uint32_t                 queueFamilyIndexCount;
1750    const uint32_t*          pQueueFamilyIndices;
1751    VkImageLayout            initialLayout;
1752} VkImageCreateInfo;
1753
1754typedef struct VkSubresourceLayout {
1755    VkDeviceSize    offset;
1756    VkDeviceSize    size;
1757    VkDeviceSize    rowPitch;
1758    VkDeviceSize    arrayPitch;
1759    VkDeviceSize    depthPitch;
1760} VkSubresourceLayout;
1761
1762typedef struct VkComponentMapping {
1763    VkComponentSwizzle    r;
1764    VkComponentSwizzle    g;
1765    VkComponentSwizzle    b;
1766    VkComponentSwizzle    a;
1767} VkComponentMapping;
1768
1769typedef struct VkImageSubresourceRange {
1770    VkImageAspectFlags    aspectMask;
1771    uint32_t              baseMipLevel;
1772    uint32_t              levelCount;
1773    uint32_t              baseArrayLayer;
1774    uint32_t              layerCount;
1775} VkImageSubresourceRange;
1776
1777typedef struct VkImageViewCreateInfo {
1778    VkStructureType            sType;
1779    const void*                pNext;
1780    VkImageViewCreateFlags     flags;
1781    VkImage                    image;
1782    VkImageViewType            viewType;
1783    VkFormat                   format;
1784    VkComponentMapping         components;
1785    VkImageSubresourceRange    subresourceRange;
1786} VkImageViewCreateInfo;
1787
1788typedef struct VkShaderModuleCreateInfo {
1789    VkStructureType              sType;
1790    const void*                  pNext;
1791    VkShaderModuleCreateFlags    flags;
1792    size_t                       codeSize;
1793    const uint32_t*              pCode;
1794} VkShaderModuleCreateInfo;
1795
1796typedef struct VkPipelineCacheCreateInfo {
1797    VkStructureType               sType;
1798    const void*                   pNext;
1799    VkPipelineCacheCreateFlags    flags;
1800    size_t                        initialDataSize;
1801    const void*                   pInitialData;
1802} VkPipelineCacheCreateInfo;
1803
1804typedef struct VkSpecializationMapEntry {
1805    uint32_t    constantID;
1806    uint32_t    offset;
1807    size_t      size;
1808} VkSpecializationMapEntry;
1809
1810typedef struct VkSpecializationInfo {
1811    uint32_t                           mapEntryCount;
1812    const VkSpecializationMapEntry*    pMapEntries;
1813    size_t                             dataSize;
1814    const void*                        pData;
1815} VkSpecializationInfo;
1816
1817typedef struct VkPipelineShaderStageCreateInfo {
1818    VkStructureType                     sType;
1819    const void*                         pNext;
1820    VkPipelineShaderStageCreateFlags    flags;
1821    VkShaderStageFlagBits               stage;
1822    VkShaderModule                      module;
1823    const char*                         pName;
1824    const VkSpecializationInfo*         pSpecializationInfo;
1825} VkPipelineShaderStageCreateInfo;
1826
1827typedef struct VkVertexInputBindingDescription {
1828    uint32_t             binding;
1829    uint32_t             stride;
1830    VkVertexInputRate    inputRate;
1831} VkVertexInputBindingDescription;
1832
1833typedef struct VkVertexInputAttributeDescription {
1834    uint32_t    location;
1835    uint32_t    binding;
1836    VkFormat    format;
1837    uint32_t    offset;
1838} VkVertexInputAttributeDescription;
1839
1840typedef struct VkPipelineVertexInputStateCreateInfo {
1841    VkStructureType                             sType;
1842    const void*                                 pNext;
1843    VkPipelineVertexInputStateCreateFlags       flags;
1844    uint32_t                                    vertexBindingDescriptionCount;
1845    const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
1846    uint32_t                                    vertexAttributeDescriptionCount;
1847    const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
1848} VkPipelineVertexInputStateCreateInfo;
1849
1850typedef struct VkPipelineInputAssemblyStateCreateInfo {
1851    VkStructureType                            sType;
1852    const void*                                pNext;
1853    VkPipelineInputAssemblyStateCreateFlags    flags;
1854    VkPrimitiveTopology                        topology;
1855    VkBool32                                   primitiveRestartEnable;
1856} VkPipelineInputAssemblyStateCreateInfo;
1857
1858typedef struct VkPipelineTessellationStateCreateInfo {
1859    VkStructureType                           sType;
1860    const void*                               pNext;
1861    VkPipelineTessellationStateCreateFlags    flags;
1862    uint32_t                                  patchControlPoints;
1863} VkPipelineTessellationStateCreateInfo;
1864
1865typedef struct VkViewport {
1866    float    x;
1867    float    y;
1868    float    width;
1869    float    height;
1870    float    minDepth;
1871    float    maxDepth;
1872} VkViewport;
1873
1874typedef struct VkOffset2D {
1875    int32_t    x;
1876    int32_t    y;
1877} VkOffset2D;
1878
1879typedef struct VkExtent2D {
1880    uint32_t    width;
1881    uint32_t    height;
1882} VkExtent2D;
1883
1884typedef struct VkRect2D {
1885    VkOffset2D    offset;
1886    VkExtent2D    extent;
1887} VkRect2D;
1888
1889typedef struct VkPipelineViewportStateCreateInfo {
1890    VkStructureType                       sType;
1891    const void*                           pNext;
1892    VkPipelineViewportStateCreateFlags    flags;
1893    uint32_t                              viewportCount;
1894    const VkViewport*                     pViewports;
1895    uint32_t                              scissorCount;
1896    const VkRect2D*                       pScissors;
1897} VkPipelineViewportStateCreateInfo;
1898
1899typedef struct VkPipelineRasterizationStateCreateInfo {
1900    VkStructureType                            sType;
1901    const void*                                pNext;
1902    VkPipelineRasterizationStateCreateFlags    flags;
1903    VkBool32                                   depthClampEnable;
1904    VkBool32                                   rasterizerDiscardEnable;
1905    VkPolygonMode                              polygonMode;
1906    VkCullModeFlags                            cullMode;
1907    VkFrontFace                                frontFace;
1908    VkBool32                                   depthBiasEnable;
1909    float                                      depthBiasConstantFactor;
1910    float                                      depthBiasClamp;
1911    float                                      depthBiasSlopeFactor;
1912    float                                      lineWidth;
1913} VkPipelineRasterizationStateCreateInfo;
1914
1915typedef struct VkPipelineMultisampleStateCreateInfo {
1916    VkStructureType                          sType;
1917    const void*                              pNext;
1918    VkPipelineMultisampleStateCreateFlags    flags;
1919    VkSampleCountFlagBits                    rasterizationSamples;
1920    VkBool32                                 sampleShadingEnable;
1921    float                                    minSampleShading;
1922    const VkSampleMask*                      pSampleMask;
1923    VkBool32                                 alphaToCoverageEnable;
1924    VkBool32                                 alphaToOneEnable;
1925} VkPipelineMultisampleStateCreateInfo;
1926
1927typedef struct VkStencilOpState {
1928    VkStencilOp    failOp;
1929    VkStencilOp    passOp;
1930    VkStencilOp    depthFailOp;
1931    VkCompareOp    compareOp;
1932    uint32_t       compareMask;
1933    uint32_t       writeMask;
1934    uint32_t       reference;
1935} VkStencilOpState;
1936
1937typedef struct VkPipelineDepthStencilStateCreateInfo {
1938    VkStructureType                           sType;
1939    const void*                               pNext;
1940    VkPipelineDepthStencilStateCreateFlags    flags;
1941    VkBool32                                  depthTestEnable;
1942    VkBool32                                  depthWriteEnable;
1943    VkCompareOp                               depthCompareOp;
1944    VkBool32                                  depthBoundsTestEnable;
1945    VkBool32                                  stencilTestEnable;
1946    VkStencilOpState                          front;
1947    VkStencilOpState                          back;
1948    float                                     minDepthBounds;
1949    float                                     maxDepthBounds;
1950} VkPipelineDepthStencilStateCreateInfo;
1951
1952typedef struct VkPipelineColorBlendAttachmentState {
1953    VkBool32                 blendEnable;
1954    VkBlendFactor            srcColorBlendFactor;
1955    VkBlendFactor            dstColorBlendFactor;
1956    VkBlendOp                colorBlendOp;
1957    VkBlendFactor            srcAlphaBlendFactor;
1958    VkBlendFactor            dstAlphaBlendFactor;
1959    VkBlendOp                alphaBlendOp;
1960    VkColorComponentFlags    colorWriteMask;
1961} VkPipelineColorBlendAttachmentState;
1962
1963typedef struct VkPipelineColorBlendStateCreateInfo {
1964    VkStructureType                               sType;
1965    const void*                                   pNext;
1966    VkPipelineColorBlendStateCreateFlags          flags;
1967    VkBool32                                      logicOpEnable;
1968    VkLogicOp                                     logicOp;
1969    uint32_t                                      attachmentCount;
1970    const VkPipelineColorBlendAttachmentState*    pAttachments;
1971    float                                         blendConstants[4];
1972} VkPipelineColorBlendStateCreateInfo;
1973
1974typedef struct VkPipelineDynamicStateCreateInfo {
1975    VkStructureType                      sType;
1976    const void*                          pNext;
1977    VkPipelineDynamicStateCreateFlags    flags;
1978    uint32_t                             dynamicStateCount;
1979    const VkDynamicState*                pDynamicStates;
1980} VkPipelineDynamicStateCreateInfo;
1981
1982typedef struct VkGraphicsPipelineCreateInfo {
1983    VkStructureType                                  sType;
1984    const void*                                      pNext;
1985    VkPipelineCreateFlags                            flags;
1986    uint32_t                                         stageCount;
1987    const VkPipelineShaderStageCreateInfo*           pStages;
1988    const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
1989    const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
1990    const VkPipelineTessellationStateCreateInfo*     pTessellationState;
1991    const VkPipelineViewportStateCreateInfo*         pViewportState;
1992    const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
1993    const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
1994    const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
1995    const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
1996    const VkPipelineDynamicStateCreateInfo*          pDynamicState;
1997    VkPipelineLayout                                 layout;
1998    VkRenderPass                                     renderPass;
1999    uint32_t                                         subpass;
2000    VkPipeline                                       basePipelineHandle;
2001    int32_t                                          basePipelineIndex;
2002} VkGraphicsPipelineCreateInfo;
2003
2004typedef struct VkComputePipelineCreateInfo {
2005    VkStructureType                    sType;
2006    const void*                        pNext;
2007    VkPipelineCreateFlags              flags;
2008    VkPipelineShaderStageCreateInfo    stage;
2009    VkPipelineLayout                   layout;
2010    VkPipeline                         basePipelineHandle;
2011    int32_t                            basePipelineIndex;
2012} VkComputePipelineCreateInfo;
2013
2014typedef struct VkPushConstantRange {
2015    VkShaderStageFlags    stageFlags;
2016    uint32_t              offset;
2017    uint32_t              size;
2018} VkPushConstantRange;
2019
2020typedef struct VkPipelineLayoutCreateInfo {
2021    VkStructureType                 sType;
2022    const void*                     pNext;
2023    VkPipelineLayoutCreateFlags     flags;
2024    uint32_t                        setLayoutCount;
2025    const VkDescriptorSetLayout*    pSetLayouts;
2026    uint32_t                        pushConstantRangeCount;
2027    const VkPushConstantRange*      pPushConstantRanges;
2028} VkPipelineLayoutCreateInfo;
2029
2030typedef struct VkSamplerCreateInfo {
2031    VkStructureType         sType;
2032    const void*             pNext;
2033    VkSamplerCreateFlags    flags;
2034    VkFilter                magFilter;
2035    VkFilter                minFilter;
2036    VkSamplerMipmapMode     mipmapMode;
2037    VkSamplerAddressMode    addressModeU;
2038    VkSamplerAddressMode    addressModeV;
2039    VkSamplerAddressMode    addressModeW;
2040    float                   mipLodBias;
2041    VkBool32                anisotropyEnable;
2042    float                   maxAnisotropy;
2043    VkBool32                compareEnable;
2044    VkCompareOp             compareOp;
2045    float                   minLod;
2046    float                   maxLod;
2047    VkBorderColor           borderColor;
2048    VkBool32                unnormalizedCoordinates;
2049} VkSamplerCreateInfo;
2050
2051typedef struct VkDescriptorSetLayoutBinding {
2052    uint32_t              binding;
2053    VkDescriptorType      descriptorType;
2054    uint32_t              descriptorCount;
2055    VkShaderStageFlags    stageFlags;
2056    const VkSampler*      pImmutableSamplers;
2057} VkDescriptorSetLayoutBinding;
2058
2059typedef struct VkDescriptorSetLayoutCreateInfo {
2060    VkStructureType                        sType;
2061    const void*                            pNext;
2062    VkDescriptorSetLayoutCreateFlags       flags;
2063    uint32_t                               bindingCount;
2064    const VkDescriptorSetLayoutBinding*    pBindings;
2065} VkDescriptorSetLayoutCreateInfo;
2066
2067typedef struct VkDescriptorPoolSize {
2068    VkDescriptorType    type;
2069    uint32_t            descriptorCount;
2070} VkDescriptorPoolSize;
2071
2072typedef struct VkDescriptorPoolCreateInfo {
2073    VkStructureType                sType;
2074    const void*                    pNext;
2075    VkDescriptorPoolCreateFlags    flags;
2076    uint32_t                       maxSets;
2077    uint32_t                       poolSizeCount;
2078    const VkDescriptorPoolSize*    pPoolSizes;
2079} VkDescriptorPoolCreateInfo;
2080
2081typedef struct VkDescriptorSetAllocateInfo {
2082    VkStructureType                 sType;
2083    const void*                     pNext;
2084    VkDescriptorPool                descriptorPool;
2085    uint32_t                        descriptorSetCount;
2086    const VkDescriptorSetLayout*    pSetLayouts;
2087} VkDescriptorSetAllocateInfo;
2088
2089typedef struct VkDescriptorImageInfo {
2090    VkSampler        sampler;
2091    VkImageView      imageView;
2092    VkImageLayout    imageLayout;
2093} VkDescriptorImageInfo;
2094
2095typedef struct VkDescriptorBufferInfo {
2096    VkBuffer        buffer;
2097    VkDeviceSize    offset;
2098    VkDeviceSize    range;
2099} VkDescriptorBufferInfo;
2100
2101typedef struct VkWriteDescriptorSet {
2102    VkStructureType                  sType;
2103    const void*                      pNext;
2104    VkDescriptorSet                  dstSet;
2105    uint32_t                         dstBinding;
2106    uint32_t                         dstArrayElement;
2107    uint32_t                         descriptorCount;
2108    VkDescriptorType                 descriptorType;
2109    const VkDescriptorImageInfo*     pImageInfo;
2110    const VkDescriptorBufferInfo*    pBufferInfo;
2111    const VkBufferView*              pTexelBufferView;
2112} VkWriteDescriptorSet;
2113
2114typedef struct VkCopyDescriptorSet {
2115    VkStructureType    sType;
2116    const void*        pNext;
2117    VkDescriptorSet    srcSet;
2118    uint32_t           srcBinding;
2119    uint32_t           srcArrayElement;
2120    VkDescriptorSet    dstSet;
2121    uint32_t           dstBinding;
2122    uint32_t           dstArrayElement;
2123    uint32_t           descriptorCount;
2124} VkCopyDescriptorSet;
2125
2126typedef struct VkFramebufferCreateInfo {
2127    VkStructureType             sType;
2128    const void*                 pNext;
2129    VkFramebufferCreateFlags    flags;
2130    VkRenderPass                renderPass;
2131    uint32_t                    attachmentCount;
2132    const VkImageView*          pAttachments;
2133    uint32_t                    width;
2134    uint32_t                    height;
2135    uint32_t                    layers;
2136} VkFramebufferCreateInfo;
2137
2138typedef struct VkAttachmentDescription {
2139    VkAttachmentDescriptionFlags    flags;
2140    VkFormat                        format;
2141    VkSampleCountFlagBits           samples;
2142    VkAttachmentLoadOp              loadOp;
2143    VkAttachmentStoreOp             storeOp;
2144    VkAttachmentLoadOp              stencilLoadOp;
2145    VkAttachmentStoreOp             stencilStoreOp;
2146    VkImageLayout                   initialLayout;
2147    VkImageLayout                   finalLayout;
2148} VkAttachmentDescription;
2149
2150typedef struct VkAttachmentReference {
2151    uint32_t         attachment;
2152    VkImageLayout    layout;
2153} VkAttachmentReference;
2154
2155typedef struct VkSubpassDescription {
2156    VkSubpassDescriptionFlags       flags;
2157    VkPipelineBindPoint             pipelineBindPoint;
2158    uint32_t                        inputAttachmentCount;
2159    const VkAttachmentReference*    pInputAttachments;
2160    uint32_t                        colorAttachmentCount;
2161    const VkAttachmentReference*    pColorAttachments;
2162    const VkAttachmentReference*    pResolveAttachments;
2163    const VkAttachmentReference*    pDepthStencilAttachment;
2164    uint32_t                        preserveAttachmentCount;
2165    const uint32_t*                 pPreserveAttachments;
2166} VkSubpassDescription;
2167
2168typedef struct VkSubpassDependency {
2169    uint32_t                srcSubpass;
2170    uint32_t                dstSubpass;
2171    VkPipelineStageFlags    srcStageMask;
2172    VkPipelineStageFlags    dstStageMask;
2173    VkAccessFlags           srcAccessMask;
2174    VkAccessFlags           dstAccessMask;
2175    VkDependencyFlags       dependencyFlags;
2176} VkSubpassDependency;
2177
2178typedef struct VkRenderPassCreateInfo {
2179    VkStructureType                   sType;
2180    const void*                       pNext;
2181    VkRenderPassCreateFlags           flags;
2182    uint32_t                          attachmentCount;
2183    const VkAttachmentDescription*    pAttachments;
2184    uint32_t                          subpassCount;
2185    const VkSubpassDescription*       pSubpasses;
2186    uint32_t                          dependencyCount;
2187    const VkSubpassDependency*        pDependencies;
2188} VkRenderPassCreateInfo;
2189
2190typedef struct VkCommandPoolCreateInfo {
2191    VkStructureType             sType;
2192    const void*                 pNext;
2193    VkCommandPoolCreateFlags    flags;
2194    uint32_t                    queueFamilyIndex;
2195} VkCommandPoolCreateInfo;
2196
2197typedef struct VkCommandBufferAllocateInfo {
2198    VkStructureType         sType;
2199    const void*             pNext;
2200    VkCommandPool           commandPool;
2201    VkCommandBufferLevel    level;
2202    uint32_t                commandBufferCount;
2203} VkCommandBufferAllocateInfo;
2204
2205typedef struct VkCommandBufferInheritanceInfo {
2206    VkStructureType                  sType;
2207    const void*                      pNext;
2208    VkRenderPass                     renderPass;
2209    uint32_t                         subpass;
2210    VkFramebuffer                    framebuffer;
2211    VkBool32                         occlusionQueryEnable;
2212    VkQueryControlFlags              queryFlags;
2213    VkQueryPipelineStatisticFlags    pipelineStatistics;
2214} VkCommandBufferInheritanceInfo;
2215
2216typedef struct VkCommandBufferBeginInfo {
2217    VkStructureType                          sType;
2218    const void*                              pNext;
2219    VkCommandBufferUsageFlags                flags;
2220    const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
2221} VkCommandBufferBeginInfo;
2222
2223typedef struct VkBufferCopy {
2224    VkDeviceSize    srcOffset;
2225    VkDeviceSize    dstOffset;
2226    VkDeviceSize    size;
2227} VkBufferCopy;
2228
2229typedef struct VkImageSubresourceLayers {
2230    VkImageAspectFlags    aspectMask;
2231    uint32_t              mipLevel;
2232    uint32_t              baseArrayLayer;
2233    uint32_t              layerCount;
2234} VkImageSubresourceLayers;
2235
2236typedef struct VkImageCopy {
2237    VkImageSubresourceLayers    srcSubresource;
2238    VkOffset3D                  srcOffset;
2239    VkImageSubresourceLayers    dstSubresource;
2240    VkOffset3D                  dstOffset;
2241    VkExtent3D                  extent;
2242} VkImageCopy;
2243
2244typedef struct VkImageBlit {
2245    VkImageSubresourceLayers    srcSubresource;
2246    VkOffset3D                  srcOffsets[2];
2247    VkImageSubresourceLayers    dstSubresource;
2248    VkOffset3D                  dstOffsets[2];
2249} VkImageBlit;
2250
2251typedef struct VkBufferImageCopy {
2252    VkDeviceSize                bufferOffset;
2253    uint32_t                    bufferRowLength;
2254    uint32_t                    bufferImageHeight;
2255    VkImageSubresourceLayers    imageSubresource;
2256    VkOffset3D                  imageOffset;
2257    VkExtent3D                  imageExtent;
2258} VkBufferImageCopy;
2259
2260typedef union VkClearColorValue {
2261    float       float32[4];
2262    int32_t     int32[4];
2263    uint32_t    uint32[4];
2264} VkClearColorValue;
2265
2266typedef struct VkClearDepthStencilValue {
2267    float       depth;
2268    uint32_t    stencil;
2269} VkClearDepthStencilValue;
2270
2271typedef union VkClearValue {
2272    VkClearColorValue           color;
2273    VkClearDepthStencilValue    depthStencil;
2274} VkClearValue;
2275
2276typedef struct VkClearAttachment {
2277    VkImageAspectFlags    aspectMask;
2278    uint32_t              colorAttachment;
2279    VkClearValue          clearValue;
2280} VkClearAttachment;
2281
2282typedef struct VkClearRect {
2283    VkRect2D    rect;
2284    uint32_t    baseArrayLayer;
2285    uint32_t    layerCount;
2286} VkClearRect;
2287
2288typedef struct VkImageResolve {
2289    VkImageSubresourceLayers    srcSubresource;
2290    VkOffset3D                  srcOffset;
2291    VkImageSubresourceLayers    dstSubresource;
2292    VkOffset3D                  dstOffset;
2293    VkExtent3D                  extent;
2294} VkImageResolve;
2295
2296typedef struct VkMemoryBarrier {
2297    VkStructureType    sType;
2298    const void*        pNext;
2299    VkAccessFlags      srcAccessMask;
2300    VkAccessFlags      dstAccessMask;
2301} VkMemoryBarrier;
2302
2303typedef struct VkBufferMemoryBarrier {
2304    VkStructureType    sType;
2305    const void*        pNext;
2306    VkAccessFlags      srcAccessMask;
2307    VkAccessFlags      dstAccessMask;
2308    uint32_t           srcQueueFamilyIndex;
2309    uint32_t           dstQueueFamilyIndex;
2310    VkBuffer           buffer;
2311    VkDeviceSize       offset;
2312    VkDeviceSize       size;
2313} VkBufferMemoryBarrier;
2314
2315typedef struct VkImageMemoryBarrier {
2316    VkStructureType            sType;
2317    const void*                pNext;
2318    VkAccessFlags              srcAccessMask;
2319    VkAccessFlags              dstAccessMask;
2320    VkImageLayout              oldLayout;
2321    VkImageLayout              newLayout;
2322    uint32_t                   srcQueueFamilyIndex;
2323    uint32_t                   dstQueueFamilyIndex;
2324    VkImage                    image;
2325    VkImageSubresourceRange    subresourceRange;
2326} VkImageMemoryBarrier;
2327
2328typedef struct VkRenderPassBeginInfo {
2329    VkStructureType        sType;
2330    const void*            pNext;
2331    VkRenderPass           renderPass;
2332    VkFramebuffer          framebuffer;
2333    VkRect2D               renderArea;
2334    uint32_t               clearValueCount;
2335    const VkClearValue*    pClearValues;
2336} VkRenderPassBeginInfo;
2337
2338typedef struct VkDispatchIndirectCommand {
2339    uint32_t    x;
2340    uint32_t    y;
2341    uint32_t    z;
2342} VkDispatchIndirectCommand;
2343
2344typedef struct VkDrawIndexedIndirectCommand {
2345    uint32_t    indexCount;
2346    uint32_t    instanceCount;
2347    uint32_t    firstIndex;
2348    int32_t     vertexOffset;
2349    uint32_t    firstInstance;
2350} VkDrawIndexedIndirectCommand;
2351
2352typedef struct VkDrawIndirectCommand {
2353    uint32_t    vertexCount;
2354    uint32_t    instanceCount;
2355    uint32_t    firstVertex;
2356    uint32_t    firstInstance;
2357} VkDrawIndirectCommand;
2358
2359
2360typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
2361typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
2362typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
2363typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
2364typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
2365typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
2366typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
2367typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
2368typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
2369typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
2370typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
2371typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
2372typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
2373typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
2374typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
2375typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
2376typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
2377typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
2378typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
2379typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
2380typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
2381typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
2382typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
2383typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
2384typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
2385typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
2386typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
2387typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
2388typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
2389typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
2390typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
2391typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
2392typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
2393typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
2394typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
2395typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
2396typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
2397typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
2398typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
2399typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
2400typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
2401typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
2402typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
2403typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
2404typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
2405typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
2406typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
2407typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
2408typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
2409typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
2410typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
2411typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
2412typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
2413typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
2414typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
2415typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
2416typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
2417typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
2418typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
2419typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
2420typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
2421typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
2422typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
2423typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
2424typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
2425typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
2426typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
2427typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
2428typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
2429typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
2430typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
2431typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
2432typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
2433typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
2434typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
2435typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
2436typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
2437typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
2438typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
2439typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
2440typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
2441typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
2442typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
2443typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
2444typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
2445typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
2446typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
2447typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
2448typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
2449typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
2450typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
2451typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
2452typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
2453typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
2454typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
2455typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
2456typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
2457typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
2458typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
2459typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
2460typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
2461typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
2462typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
2463typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
2464typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
2465typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
2466typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
2467typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
2468typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
2469typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
2470typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
2471typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
2472typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
2473typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
2474typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
2475typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
2476typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
2477typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
2478typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
2479typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2480typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2481typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
2482typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
2483typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
2484typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
2485typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
2486typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
2487typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
2488typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
2489typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
2490typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
2491typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
2492typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
2493typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
2494typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
2495typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
2496typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
2497
2498#ifndef VK_NO_PROTOTYPES
2499VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
2500    const VkInstanceCreateInfo*                 pCreateInfo,
2501    const VkAllocationCallbacks*                pAllocator,
2502    VkInstance*                                 pInstance);
2503
2504VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
2505    VkInstance                                  instance,
2506    const VkAllocationCallbacks*                pAllocator);
2507
2508VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
2509    VkInstance                                  instance,
2510    uint32_t*                                   pPhysicalDeviceCount,
2511    VkPhysicalDevice*                           pPhysicalDevices);
2512
2513VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
2514    VkPhysicalDevice                            physicalDevice,
2515    VkPhysicalDeviceFeatures*                   pFeatures);
2516
2517VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
2518    VkPhysicalDevice                            physicalDevice,
2519    VkFormat                                    format,
2520    VkFormatProperties*                         pFormatProperties);
2521
2522VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
2523    VkPhysicalDevice                            physicalDevice,
2524    VkFormat                                    format,
2525    VkImageType                                 type,
2526    VkImageTiling                               tiling,
2527    VkImageUsageFlags                           usage,
2528    VkImageCreateFlags                          flags,
2529    VkImageFormatProperties*                    pImageFormatProperties);
2530
2531VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
2532    VkPhysicalDevice                            physicalDevice,
2533    VkPhysicalDeviceProperties*                 pProperties);
2534
2535VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
2536    VkPhysicalDevice                            physicalDevice,
2537    uint32_t*                                   pQueueFamilyPropertyCount,
2538    VkQueueFamilyProperties*                    pQueueFamilyProperties);
2539
2540VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
2541    VkPhysicalDevice                            physicalDevice,
2542    VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
2543
2544VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
2545    VkInstance                                  instance,
2546    const char*                                 pName);
2547
2548VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
2549    VkDevice                                    device,
2550    const char*                                 pName);
2551
2552VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
2553    VkPhysicalDevice                            physicalDevice,
2554    const VkDeviceCreateInfo*                   pCreateInfo,
2555    const VkAllocationCallbacks*                pAllocator,
2556    VkDevice*                                   pDevice);
2557
2558VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
2559    VkDevice                                    device,
2560    const VkAllocationCallbacks*                pAllocator);
2561
2562VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
2563    const char*                                 pLayerName,
2564    uint32_t*                                   pPropertyCount,
2565    VkExtensionProperties*                      pProperties);
2566
2567VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
2568    VkPhysicalDevice                            physicalDevice,
2569    const char*                                 pLayerName,
2570    uint32_t*                                   pPropertyCount,
2571    VkExtensionProperties*                      pProperties);
2572
2573VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
2574    uint32_t*                                   pPropertyCount,
2575    VkLayerProperties*                          pProperties);
2576
2577VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
2578    VkPhysicalDevice                            physicalDevice,
2579    uint32_t*                                   pPropertyCount,
2580    VkLayerProperties*                          pProperties);
2581
2582VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
2583    VkDevice                                    device,
2584    uint32_t                                    queueFamilyIndex,
2585    uint32_t                                    queueIndex,
2586    VkQueue*                                    pQueue);
2587
2588VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
2589    VkQueue                                     queue,
2590    uint32_t                                    submitCount,
2591    const VkSubmitInfo*                         pSubmits,
2592    VkFence                                     fence);
2593
2594VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
2595    VkQueue                                     queue);
2596
2597VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
2598    VkDevice                                    device);
2599
2600VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
2601    VkDevice                                    device,
2602    const VkMemoryAllocateInfo*                 pAllocateInfo,
2603    const VkAllocationCallbacks*                pAllocator,
2604    VkDeviceMemory*                             pMemory);
2605
2606VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
2607    VkDevice                                    device,
2608    VkDeviceMemory                              memory,
2609    const VkAllocationCallbacks*                pAllocator);
2610
2611VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
2612    VkDevice                                    device,
2613    VkDeviceMemory                              memory,
2614    VkDeviceSize                                offset,
2615    VkDeviceSize                                size,
2616    VkMemoryMapFlags                            flags,
2617    void**                                      ppData);
2618
2619VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
2620    VkDevice                                    device,
2621    VkDeviceMemory                              memory);
2622
2623VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
2624    VkDevice                                    device,
2625    uint32_t                                    memoryRangeCount,
2626    const VkMappedMemoryRange*                  pMemoryRanges);
2627
2628VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
2629    VkDevice                                    device,
2630    uint32_t                                    memoryRangeCount,
2631    const VkMappedMemoryRange*                  pMemoryRanges);
2632
2633VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
2634    VkDevice                                    device,
2635    VkDeviceMemory                              memory,
2636    VkDeviceSize*                               pCommittedMemoryInBytes);
2637
2638VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
2639    VkDevice                                    device,
2640    VkBuffer                                    buffer,
2641    VkDeviceMemory                              memory,
2642    VkDeviceSize                                memoryOffset);
2643
2644VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
2645    VkDevice                                    device,
2646    VkImage                                     image,
2647    VkDeviceMemory                              memory,
2648    VkDeviceSize                                memoryOffset);
2649
2650VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
2651    VkDevice                                    device,
2652    VkBuffer                                    buffer,
2653    VkMemoryRequirements*                       pMemoryRequirements);
2654
2655VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
2656    VkDevice                                    device,
2657    VkImage                                     image,
2658    VkMemoryRequirements*                       pMemoryRequirements);
2659
2660VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
2661    VkDevice                                    device,
2662    VkImage                                     image,
2663    uint32_t*                                   pSparseMemoryRequirementCount,
2664    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
2665
2666VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
2667    VkPhysicalDevice                            physicalDevice,
2668    VkFormat                                    format,
2669    VkImageType                                 type,
2670    VkSampleCountFlagBits                       samples,
2671    VkImageUsageFlags                           usage,
2672    VkImageTiling                               tiling,
2673    uint32_t*                                   pPropertyCount,
2674    VkSparseImageFormatProperties*              pProperties);
2675
2676VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
2677    VkQueue                                     queue,
2678    uint32_t                                    bindInfoCount,
2679    const VkBindSparseInfo*                     pBindInfo,
2680    VkFence                                     fence);
2681
2682VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
2683    VkDevice                                    device,
2684    const VkFenceCreateInfo*                    pCreateInfo,
2685    const VkAllocationCallbacks*                pAllocator,
2686    VkFence*                                    pFence);
2687
2688VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
2689    VkDevice                                    device,
2690    VkFence                                     fence,
2691    const VkAllocationCallbacks*                pAllocator);
2692
2693VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
2694    VkDevice                                    device,
2695    uint32_t                                    fenceCount,
2696    const VkFence*                              pFences);
2697
2698VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
2699    VkDevice                                    device,
2700    VkFence                                     fence);
2701
2702VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
2703    VkDevice                                    device,
2704    uint32_t                                    fenceCount,
2705    const VkFence*                              pFences,
2706    VkBool32                                    waitAll,
2707    uint64_t                                    timeout);
2708
2709VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
2710    VkDevice                                    device,
2711    const VkSemaphoreCreateInfo*                pCreateInfo,
2712    const VkAllocationCallbacks*                pAllocator,
2713    VkSemaphore*                                pSemaphore);
2714
2715VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
2716    VkDevice                                    device,
2717    VkSemaphore                                 semaphore,
2718    const VkAllocationCallbacks*                pAllocator);
2719
2720VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
2721    VkDevice                                    device,
2722    const VkEventCreateInfo*                    pCreateInfo,
2723    const VkAllocationCallbacks*                pAllocator,
2724    VkEvent*                                    pEvent);
2725
2726VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
2727    VkDevice                                    device,
2728    VkEvent                                     event,
2729    const VkAllocationCallbacks*                pAllocator);
2730
2731VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
2732    VkDevice                                    device,
2733    VkEvent                                     event);
2734
2735VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
2736    VkDevice                                    device,
2737    VkEvent                                     event);
2738
2739VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
2740    VkDevice                                    device,
2741    VkEvent                                     event);
2742
2743VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
2744    VkDevice                                    device,
2745    const VkQueryPoolCreateInfo*                pCreateInfo,
2746    const VkAllocationCallbacks*                pAllocator,
2747    VkQueryPool*                                pQueryPool);
2748
2749VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
2750    VkDevice                                    device,
2751    VkQueryPool                                 queryPool,
2752    const VkAllocationCallbacks*                pAllocator);
2753
2754VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
2755    VkDevice                                    device,
2756    VkQueryPool                                 queryPool,
2757    uint32_t                                    firstQuery,
2758    uint32_t                                    queryCount,
2759    size_t                                      dataSize,
2760    void*                                       pData,
2761    VkDeviceSize                                stride,
2762    VkQueryResultFlags                          flags);
2763
2764VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
2765    VkDevice                                    device,
2766    const VkBufferCreateInfo*                   pCreateInfo,
2767    const VkAllocationCallbacks*                pAllocator,
2768    VkBuffer*                                   pBuffer);
2769
2770VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
2771    VkDevice                                    device,
2772    VkBuffer                                    buffer,
2773    const VkAllocationCallbacks*                pAllocator);
2774
2775VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
2776    VkDevice                                    device,
2777    const VkBufferViewCreateInfo*               pCreateInfo,
2778    const VkAllocationCallbacks*                pAllocator,
2779    VkBufferView*                               pView);
2780
2781VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
2782    VkDevice                                    device,
2783    VkBufferView                                bufferView,
2784    const VkAllocationCallbacks*                pAllocator);
2785
2786VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
2787    VkDevice                                    device,
2788    const VkImageCreateInfo*                    pCreateInfo,
2789    const VkAllocationCallbacks*                pAllocator,
2790    VkImage*                                    pImage);
2791
2792VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
2793    VkDevice                                    device,
2794    VkImage                                     image,
2795    const VkAllocationCallbacks*                pAllocator);
2796
2797VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
2798    VkDevice                                    device,
2799    VkImage                                     image,
2800    const VkImageSubresource*                   pSubresource,
2801    VkSubresourceLayout*                        pLayout);
2802
2803VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
2804    VkDevice                                    device,
2805    const VkImageViewCreateInfo*                pCreateInfo,
2806    const VkAllocationCallbacks*                pAllocator,
2807    VkImageView*                                pView);
2808
2809VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
2810    VkDevice                                    device,
2811    VkImageView                                 imageView,
2812    const VkAllocationCallbacks*                pAllocator);
2813
2814VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
2815    VkDevice                                    device,
2816    const VkShaderModuleCreateInfo*             pCreateInfo,
2817    const VkAllocationCallbacks*                pAllocator,
2818    VkShaderModule*                             pShaderModule);
2819
2820VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
2821    VkDevice                                    device,
2822    VkShaderModule                              shaderModule,
2823    const VkAllocationCallbacks*                pAllocator);
2824
2825VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
2826    VkDevice                                    device,
2827    const VkPipelineCacheCreateInfo*            pCreateInfo,
2828    const VkAllocationCallbacks*                pAllocator,
2829    VkPipelineCache*                            pPipelineCache);
2830
2831VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
2832    VkDevice                                    device,
2833    VkPipelineCache                             pipelineCache,
2834    const VkAllocationCallbacks*                pAllocator);
2835
2836VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
2837    VkDevice                                    device,
2838    VkPipelineCache                             pipelineCache,
2839    size_t*                                     pDataSize,
2840    void*                                       pData);
2841
2842VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
2843    VkDevice                                    device,
2844    VkPipelineCache                             dstCache,
2845    uint32_t                                    srcCacheCount,
2846    const VkPipelineCache*                      pSrcCaches);
2847
2848VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
2849    VkDevice                                    device,
2850    VkPipelineCache                             pipelineCache,
2851    uint32_t                                    createInfoCount,
2852    const VkGraphicsPipelineCreateInfo*         pCreateInfos,
2853    const VkAllocationCallbacks*                pAllocator,
2854    VkPipeline*                                 pPipelines);
2855
2856VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
2857    VkDevice                                    device,
2858    VkPipelineCache                             pipelineCache,
2859    uint32_t                                    createInfoCount,
2860    const VkComputePipelineCreateInfo*          pCreateInfos,
2861    const VkAllocationCallbacks*                pAllocator,
2862    VkPipeline*                                 pPipelines);
2863
2864VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
2865    VkDevice                                    device,
2866    VkPipeline                                  pipeline,
2867    const VkAllocationCallbacks*                pAllocator);
2868
2869VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
2870    VkDevice                                    device,
2871    const VkPipelineLayoutCreateInfo*           pCreateInfo,
2872    const VkAllocationCallbacks*                pAllocator,
2873    VkPipelineLayout*                           pPipelineLayout);
2874
2875VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
2876    VkDevice                                    device,
2877    VkPipelineLayout                            pipelineLayout,
2878    const VkAllocationCallbacks*                pAllocator);
2879
2880VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
2881    VkDevice                                    device,
2882    const VkSamplerCreateInfo*                  pCreateInfo,
2883    const VkAllocationCallbacks*                pAllocator,
2884    VkSampler*                                  pSampler);
2885
2886VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
2887    VkDevice                                    device,
2888    VkSampler                                   sampler,
2889    const VkAllocationCallbacks*                pAllocator);
2890
2891VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
2892    VkDevice                                    device,
2893    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
2894    const VkAllocationCallbacks*                pAllocator,
2895    VkDescriptorSetLayout*                      pSetLayout);
2896
2897VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
2898    VkDevice                                    device,
2899    VkDescriptorSetLayout                       descriptorSetLayout,
2900    const VkAllocationCallbacks*                pAllocator);
2901
2902VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
2903    VkDevice                                    device,
2904    const VkDescriptorPoolCreateInfo*           pCreateInfo,
2905    const VkAllocationCallbacks*                pAllocator,
2906    VkDescriptorPool*                           pDescriptorPool);
2907
2908VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
2909    VkDevice                                    device,
2910    VkDescriptorPool                            descriptorPool,
2911    const VkAllocationCallbacks*                pAllocator);
2912
2913VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
2914    VkDevice                                    device,
2915    VkDescriptorPool                            descriptorPool,
2916    VkDescriptorPoolResetFlags                  flags);
2917
2918VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
2919    VkDevice                                    device,
2920    const VkDescriptorSetAllocateInfo*          pAllocateInfo,
2921    VkDescriptorSet*                            pDescriptorSets);
2922
2923VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
2924    VkDevice                                    device,
2925    VkDescriptorPool                            descriptorPool,
2926    uint32_t                                    descriptorSetCount,
2927    const VkDescriptorSet*                      pDescriptorSets);
2928
2929VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
2930    VkDevice                                    device,
2931    uint32_t                                    descriptorWriteCount,
2932    const VkWriteDescriptorSet*                 pDescriptorWrites,
2933    uint32_t                                    descriptorCopyCount,
2934    const VkCopyDescriptorSet*                  pDescriptorCopies);
2935
2936VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
2937    VkDevice                                    device,
2938    const VkFramebufferCreateInfo*              pCreateInfo,
2939    const VkAllocationCallbacks*                pAllocator,
2940    VkFramebuffer*                              pFramebuffer);
2941
2942VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
2943    VkDevice                                    device,
2944    VkFramebuffer                               framebuffer,
2945    const VkAllocationCallbacks*                pAllocator);
2946
2947VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
2948    VkDevice                                    device,
2949    const VkRenderPassCreateInfo*               pCreateInfo,
2950    const VkAllocationCallbacks*                pAllocator,
2951    VkRenderPass*                               pRenderPass);
2952
2953VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
2954    VkDevice                                    device,
2955    VkRenderPass                                renderPass,
2956    const VkAllocationCallbacks*                pAllocator);
2957
2958VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
2959    VkDevice                                    device,
2960    VkRenderPass                                renderPass,
2961    VkExtent2D*                                 pGranularity);
2962
2963VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
2964    VkDevice                                    device,
2965    const VkCommandPoolCreateInfo*              pCreateInfo,
2966    const VkAllocationCallbacks*                pAllocator,
2967    VkCommandPool*                              pCommandPool);
2968
2969VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
2970    VkDevice                                    device,
2971    VkCommandPool                               commandPool,
2972    const VkAllocationCallbacks*                pAllocator);
2973
2974VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
2975    VkDevice                                    device,
2976    VkCommandPool                               commandPool,
2977    VkCommandPoolResetFlags                     flags);
2978
2979VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
2980    VkDevice                                    device,
2981    const VkCommandBufferAllocateInfo*          pAllocateInfo,
2982    VkCommandBuffer*                            pCommandBuffers);
2983
2984VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
2985    VkDevice                                    device,
2986    VkCommandPool                               commandPool,
2987    uint32_t                                    commandBufferCount,
2988    const VkCommandBuffer*                      pCommandBuffers);
2989
2990VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
2991    VkCommandBuffer                             commandBuffer,
2992    const VkCommandBufferBeginInfo*             pBeginInfo);
2993
2994VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
2995    VkCommandBuffer                             commandBuffer);
2996
2997VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
2998    VkCommandBuffer                             commandBuffer,
2999    VkCommandBufferResetFlags                   flags);
3000
3001VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
3002    VkCommandBuffer                             commandBuffer,
3003    VkPipelineBindPoint                         pipelineBindPoint,
3004    VkPipeline                                  pipeline);
3005
3006VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
3007    VkCommandBuffer                             commandBuffer,
3008    uint32_t                                    firstViewport,
3009    uint32_t                                    viewportCount,
3010    const VkViewport*                           pViewports);
3011
3012VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
3013    VkCommandBuffer                             commandBuffer,
3014    uint32_t                                    firstScissor,
3015    uint32_t                                    scissorCount,
3016    const VkRect2D*                             pScissors);
3017
3018VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
3019    VkCommandBuffer                             commandBuffer,
3020    float                                       lineWidth);
3021
3022VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
3023    VkCommandBuffer                             commandBuffer,
3024    float                                       depthBiasConstantFactor,
3025    float                                       depthBiasClamp,
3026    float                                       depthBiasSlopeFactor);
3027
3028VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
3029    VkCommandBuffer                             commandBuffer,
3030    const float                                 blendConstants[4]);
3031
3032VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
3033    VkCommandBuffer                             commandBuffer,
3034    float                                       minDepthBounds,
3035    float                                       maxDepthBounds);
3036
3037VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
3038    VkCommandBuffer                             commandBuffer,
3039    VkStencilFaceFlags                          faceMask,
3040    uint32_t                                    compareMask);
3041
3042VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
3043    VkCommandBuffer                             commandBuffer,
3044    VkStencilFaceFlags                          faceMask,
3045    uint32_t                                    writeMask);
3046
3047VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
3048    VkCommandBuffer                             commandBuffer,
3049    VkStencilFaceFlags                          faceMask,
3050    uint32_t                                    reference);
3051
3052VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
3053    VkCommandBuffer                             commandBuffer,
3054    VkPipelineBindPoint                         pipelineBindPoint,
3055    VkPipelineLayout                            layout,
3056    uint32_t                                    firstSet,
3057    uint32_t                                    descriptorSetCount,
3058    const VkDescriptorSet*                      pDescriptorSets,
3059    uint32_t                                    dynamicOffsetCount,
3060    const uint32_t*                             pDynamicOffsets);
3061
3062VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
3063    VkCommandBuffer                             commandBuffer,
3064    VkBuffer                                    buffer,
3065    VkDeviceSize                                offset,
3066    VkIndexType                                 indexType);
3067
3068VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
3069    VkCommandBuffer                             commandBuffer,
3070    uint32_t                                    firstBinding,
3071    uint32_t                                    bindingCount,
3072    const VkBuffer*                             pBuffers,
3073    const VkDeviceSize*                         pOffsets);
3074
3075VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
3076    VkCommandBuffer                             commandBuffer,
3077    uint32_t                                    vertexCount,
3078    uint32_t                                    instanceCount,
3079    uint32_t                                    firstVertex,
3080    uint32_t                                    firstInstance);
3081
3082VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
3083    VkCommandBuffer                             commandBuffer,
3084    uint32_t                                    indexCount,
3085    uint32_t                                    instanceCount,
3086    uint32_t                                    firstIndex,
3087    int32_t                                     vertexOffset,
3088    uint32_t                                    firstInstance);
3089
3090VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
3091    VkCommandBuffer                             commandBuffer,
3092    VkBuffer                                    buffer,
3093    VkDeviceSize                                offset,
3094    uint32_t                                    drawCount,
3095    uint32_t                                    stride);
3096
3097VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
3098    VkCommandBuffer                             commandBuffer,
3099    VkBuffer                                    buffer,
3100    VkDeviceSize                                offset,
3101    uint32_t                                    drawCount,
3102    uint32_t                                    stride);
3103
3104VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
3105    VkCommandBuffer                             commandBuffer,
3106    uint32_t                                    groupCountX,
3107    uint32_t                                    groupCountY,
3108    uint32_t                                    groupCountZ);
3109
3110VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
3111    VkCommandBuffer                             commandBuffer,
3112    VkBuffer                                    buffer,
3113    VkDeviceSize                                offset);
3114
3115VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
3116    VkCommandBuffer                             commandBuffer,
3117    VkBuffer                                    srcBuffer,
3118    VkBuffer                                    dstBuffer,
3119    uint32_t                                    regionCount,
3120    const VkBufferCopy*                         pRegions);
3121
3122VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
3123    VkCommandBuffer                             commandBuffer,
3124    VkImage                                     srcImage,
3125    VkImageLayout                               srcImageLayout,
3126    VkImage                                     dstImage,
3127    VkImageLayout                               dstImageLayout,
3128    uint32_t                                    regionCount,
3129    const VkImageCopy*                          pRegions);
3130
3131VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
3132    VkCommandBuffer                             commandBuffer,
3133    VkImage                                     srcImage,
3134    VkImageLayout                               srcImageLayout,
3135    VkImage                                     dstImage,
3136    VkImageLayout                               dstImageLayout,
3137    uint32_t                                    regionCount,
3138    const VkImageBlit*                          pRegions,
3139    VkFilter                                    filter);
3140
3141VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
3142    VkCommandBuffer                             commandBuffer,
3143    VkBuffer                                    srcBuffer,
3144    VkImage                                     dstImage,
3145    VkImageLayout                               dstImageLayout,
3146    uint32_t                                    regionCount,
3147    const VkBufferImageCopy*                    pRegions);
3148
3149VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
3150    VkCommandBuffer                             commandBuffer,
3151    VkImage                                     srcImage,
3152    VkImageLayout                               srcImageLayout,
3153    VkBuffer                                    dstBuffer,
3154    uint32_t                                    regionCount,
3155    const VkBufferImageCopy*                    pRegions);
3156
3157VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
3158    VkCommandBuffer                             commandBuffer,
3159    VkBuffer                                    dstBuffer,
3160    VkDeviceSize                                dstOffset,
3161    VkDeviceSize                                dataSize,
3162    const void*                                 pData);
3163
3164VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
3165    VkCommandBuffer                             commandBuffer,
3166    VkBuffer                                    dstBuffer,
3167    VkDeviceSize                                dstOffset,
3168    VkDeviceSize                                size,
3169    uint32_t                                    data);
3170
3171VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
3172    VkCommandBuffer                             commandBuffer,
3173    VkImage                                     image,
3174    VkImageLayout                               imageLayout,
3175    const VkClearColorValue*                    pColor,
3176    uint32_t                                    rangeCount,
3177    const VkImageSubresourceRange*              pRanges);
3178
3179VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
3180    VkCommandBuffer                             commandBuffer,
3181    VkImage                                     image,
3182    VkImageLayout                               imageLayout,
3183    const VkClearDepthStencilValue*             pDepthStencil,
3184    uint32_t                                    rangeCount,
3185    const VkImageSubresourceRange*              pRanges);
3186
3187VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
3188    VkCommandBuffer                             commandBuffer,
3189    uint32_t                                    attachmentCount,
3190    const VkClearAttachment*                    pAttachments,
3191    uint32_t                                    rectCount,
3192    const VkClearRect*                          pRects);
3193
3194VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
3195    VkCommandBuffer                             commandBuffer,
3196    VkImage                                     srcImage,
3197    VkImageLayout                               srcImageLayout,
3198    VkImage                                     dstImage,
3199    VkImageLayout                               dstImageLayout,
3200    uint32_t                                    regionCount,
3201    const VkImageResolve*                       pRegions);
3202
3203VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
3204    VkCommandBuffer                             commandBuffer,
3205    VkEvent                                     event,
3206    VkPipelineStageFlags                        stageMask);
3207
3208VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
3209    VkCommandBuffer                             commandBuffer,
3210    VkEvent                                     event,
3211    VkPipelineStageFlags                        stageMask);
3212
3213VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
3214    VkCommandBuffer                             commandBuffer,
3215    uint32_t                                    eventCount,
3216    const VkEvent*                              pEvents,
3217    VkPipelineStageFlags                        srcStageMask,
3218    VkPipelineStageFlags                        dstStageMask,
3219    uint32_t                                    memoryBarrierCount,
3220    const VkMemoryBarrier*                      pMemoryBarriers,
3221    uint32_t                                    bufferMemoryBarrierCount,
3222    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
3223    uint32_t                                    imageMemoryBarrierCount,
3224    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
3225
3226VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
3227    VkCommandBuffer                             commandBuffer,
3228    VkPipelineStageFlags                        srcStageMask,
3229    VkPipelineStageFlags                        dstStageMask,
3230    VkDependencyFlags                           dependencyFlags,
3231    uint32_t                                    memoryBarrierCount,
3232    const VkMemoryBarrier*                      pMemoryBarriers,
3233    uint32_t                                    bufferMemoryBarrierCount,
3234    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
3235    uint32_t                                    imageMemoryBarrierCount,
3236    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
3237
3238VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
3239    VkCommandBuffer                             commandBuffer,
3240    VkQueryPool                                 queryPool,
3241    uint32_t                                    query,
3242    VkQueryControlFlags                         flags);
3243
3244VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
3245    VkCommandBuffer                             commandBuffer,
3246    VkQueryPool                                 queryPool,
3247    uint32_t                                    query);
3248
3249VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
3250    VkCommandBuffer                             commandBuffer,
3251    VkQueryPool                                 queryPool,
3252    uint32_t                                    firstQuery,
3253    uint32_t                                    queryCount);
3254
3255VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
3256    VkCommandBuffer                             commandBuffer,
3257    VkPipelineStageFlagBits                     pipelineStage,
3258    VkQueryPool                                 queryPool,
3259    uint32_t                                    query);
3260
3261VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
3262    VkCommandBuffer                             commandBuffer,
3263    VkQueryPool                                 queryPool,
3264    uint32_t                                    firstQuery,
3265    uint32_t                                    queryCount,
3266    VkBuffer                                    dstBuffer,
3267    VkDeviceSize                                dstOffset,
3268    VkDeviceSize                                stride,
3269    VkQueryResultFlags                          flags);
3270
3271VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
3272    VkCommandBuffer                             commandBuffer,
3273    VkPipelineLayout                            layout,
3274    VkShaderStageFlags                          stageFlags,
3275    uint32_t                                    offset,
3276    uint32_t                                    size,
3277    const void*                                 pValues);
3278
3279VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
3280    VkCommandBuffer                             commandBuffer,
3281    const VkRenderPassBeginInfo*                pRenderPassBegin,
3282    VkSubpassContents                           contents);
3283
3284VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
3285    VkCommandBuffer                             commandBuffer,
3286    VkSubpassContents                           contents);
3287
3288VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
3289    VkCommandBuffer                             commandBuffer);
3290
3291VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
3292    VkCommandBuffer                             commandBuffer,
3293    uint32_t                                    commandBufferCount,
3294    const VkCommandBuffer*                      pCommandBuffers);
3295#endif
3296
3297#define VK_KHR_surface 1
3298VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
3299
3300#define VK_KHR_SURFACE_SPEC_VERSION       25
3301#define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
3302#define VK_COLORSPACE_SRGB_NONLINEAR_KHR  VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
3303
3304
3305typedef enum VkColorSpaceKHR {
3306    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
3307    VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
3308    VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
3309    VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003,
3310    VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
3311    VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
3312    VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
3313    VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
3314    VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
3315    VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
3316    VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
3317    VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
3318    VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
3319    VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
3320    VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
3321    VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
3322    VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
3323    VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
3324} VkColorSpaceKHR;
3325
3326typedef enum VkPresentModeKHR {
3327    VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
3328    VK_PRESENT_MODE_MAILBOX_KHR = 1,
3329    VK_PRESENT_MODE_FIFO_KHR = 2,
3330    VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
3331    VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
3332    VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
3333    VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
3334    VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
3335    VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
3336    VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
3337} VkPresentModeKHR;
3338
3339
3340typedef enum VkSurfaceTransformFlagBitsKHR {
3341    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
3342    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
3343    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
3344    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
3345    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
3346    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
3347    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
3348    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
3349    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
3350    VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
3351} VkSurfaceTransformFlagBitsKHR;
3352typedef VkFlags VkSurfaceTransformFlagsKHR;
3353
3354typedef enum VkCompositeAlphaFlagBitsKHR {
3355    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
3356    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
3357    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
3358    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
3359    VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
3360} VkCompositeAlphaFlagBitsKHR;
3361typedef VkFlags VkCompositeAlphaFlagsKHR;
3362
3363typedef struct VkSurfaceCapabilitiesKHR {
3364    uint32_t                         minImageCount;
3365    uint32_t                         maxImageCount;
3366    VkExtent2D                       currentExtent;
3367    VkExtent2D                       minImageExtent;
3368    VkExtent2D                       maxImageExtent;
3369    uint32_t                         maxImageArrayLayers;
3370    VkSurfaceTransformFlagsKHR       supportedTransforms;
3371    VkSurfaceTransformFlagBitsKHR    currentTransform;
3372    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
3373    VkImageUsageFlags                supportedUsageFlags;
3374} VkSurfaceCapabilitiesKHR;
3375
3376typedef struct VkSurfaceFormatKHR {
3377    VkFormat           format;
3378    VkColorSpaceKHR    colorSpace;
3379} VkSurfaceFormatKHR;
3380
3381
3382typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
3383typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
3384typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
3385typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
3386typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
3387
3388#ifndef VK_NO_PROTOTYPES
3389VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
3390    VkInstance                                  instance,
3391    VkSurfaceKHR                                surface,
3392    const VkAllocationCallbacks*                pAllocator);
3393
3394VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
3395    VkPhysicalDevice                            physicalDevice,
3396    uint32_t                                    queueFamilyIndex,
3397    VkSurfaceKHR                                surface,
3398    VkBool32*                                   pSupported);
3399
3400VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
3401    VkPhysicalDevice                            physicalDevice,
3402    VkSurfaceKHR                                surface,
3403    VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
3404
3405VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
3406    VkPhysicalDevice                            physicalDevice,
3407    VkSurfaceKHR                                surface,
3408    uint32_t*                                   pSurfaceFormatCount,
3409    VkSurfaceFormatKHR*                         pSurfaceFormats);
3410
3411VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
3412    VkPhysicalDevice                            physicalDevice,
3413    VkSurfaceKHR                                surface,
3414    uint32_t*                                   pPresentModeCount,
3415    VkPresentModeKHR*                           pPresentModes);
3416#endif
3417
3418#define VK_KHR_swapchain 1
3419VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
3420
3421#define VK_KHR_SWAPCHAIN_SPEC_VERSION     68
3422#define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
3423
3424
3425typedef enum VkSwapchainCreateFlagBitsKHR {
3426    VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001,
3427    VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
3428} VkSwapchainCreateFlagBitsKHR;
3429typedef VkFlags VkSwapchainCreateFlagsKHR;
3430
3431typedef struct VkSwapchainCreateInfoKHR {
3432    VkStructureType                  sType;
3433    const void*                      pNext;
3434    VkSwapchainCreateFlagsKHR        flags;
3435    VkSurfaceKHR                     surface;
3436    uint32_t                         minImageCount;
3437    VkFormat                         imageFormat;
3438    VkColorSpaceKHR                  imageColorSpace;
3439    VkExtent2D                       imageExtent;
3440    uint32_t                         imageArrayLayers;
3441    VkImageUsageFlags                imageUsage;
3442    VkSharingMode                    imageSharingMode;
3443    uint32_t                         queueFamilyIndexCount;
3444    const uint32_t*                  pQueueFamilyIndices;
3445    VkSurfaceTransformFlagBitsKHR    preTransform;
3446    VkCompositeAlphaFlagBitsKHR      compositeAlpha;
3447    VkPresentModeKHR                 presentMode;
3448    VkBool32                         clipped;
3449    VkSwapchainKHR                   oldSwapchain;
3450} VkSwapchainCreateInfoKHR;
3451
3452typedef struct VkPresentInfoKHR {
3453    VkStructureType          sType;
3454    const void*              pNext;
3455    uint32_t                 waitSemaphoreCount;
3456    const VkSemaphore*       pWaitSemaphores;
3457    uint32_t                 swapchainCount;
3458    const VkSwapchainKHR*    pSwapchains;
3459    const uint32_t*          pImageIndices;
3460    VkResult*                pResults;
3461} VkPresentInfoKHR;
3462
3463
3464typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
3465typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
3466typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
3467typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
3468typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
3469
3470#ifndef VK_NO_PROTOTYPES
3471VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
3472    VkDevice                                    device,
3473    const VkSwapchainCreateInfoKHR*             pCreateInfo,
3474    const VkAllocationCallbacks*                pAllocator,
3475    VkSwapchainKHR*                             pSwapchain);
3476
3477VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
3478    VkDevice                                    device,
3479    VkSwapchainKHR                              swapchain,
3480    const VkAllocationCallbacks*                pAllocator);
3481
3482VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
3483    VkDevice                                    device,
3484    VkSwapchainKHR                              swapchain,
3485    uint32_t*                                   pSwapchainImageCount,
3486    VkImage*                                    pSwapchainImages);
3487
3488VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
3489    VkDevice                                    device,
3490    VkSwapchainKHR                              swapchain,
3491    uint64_t                                    timeout,
3492    VkSemaphore                                 semaphore,
3493    VkFence                                     fence,
3494    uint32_t*                                   pImageIndex);
3495
3496VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
3497    VkQueue                                     queue,
3498    const VkPresentInfoKHR*                     pPresentInfo);
3499#endif
3500
3501#define VK_KHR_display 1
3502VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
3503VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
3504
3505#define VK_KHR_DISPLAY_SPEC_VERSION       21
3506#define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
3507
3508
3509typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
3510    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
3511    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
3512    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
3513    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
3514    VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
3515} VkDisplayPlaneAlphaFlagBitsKHR;
3516typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
3517typedef VkFlags VkDisplayModeCreateFlagsKHR;
3518typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
3519
3520typedef struct VkDisplayPropertiesKHR {
3521    VkDisplayKHR                  display;
3522    const char*                   displayName;
3523    VkExtent2D                    physicalDimensions;
3524    VkExtent2D                    physicalResolution;
3525    VkSurfaceTransformFlagsKHR    supportedTransforms;
3526    VkBool32                      planeReorderPossible;
3527    VkBool32                      persistentContent;
3528} VkDisplayPropertiesKHR;
3529
3530typedef struct VkDisplayModeParametersKHR {
3531    VkExtent2D    visibleRegion;
3532    uint32_t      refreshRate;
3533} VkDisplayModeParametersKHR;
3534
3535typedef struct VkDisplayModePropertiesKHR {
3536    VkDisplayModeKHR              displayMode;
3537    VkDisplayModeParametersKHR    parameters;
3538} VkDisplayModePropertiesKHR;
3539
3540typedef struct VkDisplayModeCreateInfoKHR {
3541    VkStructureType                sType;
3542    const void*                    pNext;
3543    VkDisplayModeCreateFlagsKHR    flags;
3544    VkDisplayModeParametersKHR     parameters;
3545} VkDisplayModeCreateInfoKHR;
3546
3547typedef struct VkDisplayPlaneCapabilitiesKHR {
3548    VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
3549    VkOffset2D                     minSrcPosition;
3550    VkOffset2D                     maxSrcPosition;
3551    VkExtent2D                     minSrcExtent;
3552    VkExtent2D                     maxSrcExtent;
3553    VkOffset2D                     minDstPosition;
3554    VkOffset2D                     maxDstPosition;
3555    VkExtent2D                     minDstExtent;
3556    VkExtent2D                     maxDstExtent;
3557} VkDisplayPlaneCapabilitiesKHR;
3558
3559typedef struct VkDisplayPlanePropertiesKHR {
3560    VkDisplayKHR    currentDisplay;
3561    uint32_t        currentStackIndex;
3562} VkDisplayPlanePropertiesKHR;
3563
3564typedef struct VkDisplaySurfaceCreateInfoKHR {
3565    VkStructureType                   sType;
3566    const void*                       pNext;
3567    VkDisplaySurfaceCreateFlagsKHR    flags;
3568    VkDisplayModeKHR                  displayMode;
3569    uint32_t                          planeIndex;
3570    uint32_t                          planeStackIndex;
3571    VkSurfaceTransformFlagBitsKHR     transform;
3572    float                             globalAlpha;
3573    VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
3574    VkExtent2D                        imageExtent;
3575} VkDisplaySurfaceCreateInfoKHR;
3576
3577
3578typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
3579typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
3580typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
3581typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
3582typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
3583typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
3584typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3585
3586#ifndef VK_NO_PROTOTYPES
3587VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
3588    VkPhysicalDevice                            physicalDevice,
3589    uint32_t*                                   pPropertyCount,
3590    VkDisplayPropertiesKHR*                     pProperties);
3591
3592VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
3593    VkPhysicalDevice                            physicalDevice,
3594    uint32_t*                                   pPropertyCount,
3595    VkDisplayPlanePropertiesKHR*                pProperties);
3596
3597VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
3598    VkPhysicalDevice                            physicalDevice,
3599    uint32_t                                    planeIndex,
3600    uint32_t*                                   pDisplayCount,
3601    VkDisplayKHR*                               pDisplays);
3602
3603VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
3604    VkPhysicalDevice                            physicalDevice,
3605    VkDisplayKHR                                display,
3606    uint32_t*                                   pPropertyCount,
3607    VkDisplayModePropertiesKHR*                 pProperties);
3608
3609VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
3610    VkPhysicalDevice                            physicalDevice,
3611    VkDisplayKHR                                display,
3612    const VkDisplayModeCreateInfoKHR*           pCreateInfo,
3613    const VkAllocationCallbacks*                pAllocator,
3614    VkDisplayModeKHR*                           pMode);
3615
3616VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
3617    VkPhysicalDevice                            physicalDevice,
3618    VkDisplayModeKHR                            mode,
3619    uint32_t                                    planeIndex,
3620    VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
3621
3622VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
3623    VkInstance                                  instance,
3624    const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
3625    const VkAllocationCallbacks*                pAllocator,
3626    VkSurfaceKHR*                               pSurface);
3627#endif
3628
3629#define VK_KHR_display_swapchain 1
3630#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
3631#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
3632
3633typedef struct VkDisplayPresentInfoKHR {
3634    VkStructureType    sType;
3635    const void*        pNext;
3636    VkRect2D           srcRect;
3637    VkRect2D           dstRect;
3638    VkBool32           persistent;
3639} VkDisplayPresentInfoKHR;
3640
3641
3642typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
3643
3644#ifndef VK_NO_PROTOTYPES
3645VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
3646    VkDevice                                    device,
3647    uint32_t                                    swapchainCount,
3648    const VkSwapchainCreateInfoKHR*             pCreateInfos,
3649    const VkAllocationCallbacks*                pAllocator,
3650    VkSwapchainKHR*                             pSwapchains);
3651#endif
3652
3653#ifdef VK_USE_PLATFORM_XLIB_KHR
3654#define VK_KHR_xlib_surface 1
3655#include <X11/Xlib.h>
3656
3657#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
3658#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
3659
3660typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
3661
3662typedef struct VkXlibSurfaceCreateInfoKHR {
3663    VkStructureType                sType;
3664    const void*                    pNext;
3665    VkXlibSurfaceCreateFlagsKHR    flags;
3666    Display*                       dpy;
3667    Window                         window;
3668} VkXlibSurfaceCreateInfoKHR;
3669
3670
3671typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3672typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
3673
3674#ifndef VK_NO_PROTOTYPES
3675VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
3676    VkInstance                                  instance,
3677    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
3678    const VkAllocationCallbacks*                pAllocator,
3679    VkSurfaceKHR*                               pSurface);
3680
3681VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
3682    VkPhysicalDevice                            physicalDevice,
3683    uint32_t                                    queueFamilyIndex,
3684    Display*                                    dpy,
3685    VisualID                                    visualID);
3686#endif
3687#endif /* VK_USE_PLATFORM_XLIB_KHR */
3688
3689#ifdef VK_USE_PLATFORM_XCB_KHR
3690#define VK_KHR_xcb_surface 1
3691#include <xcb/xcb.h>
3692
3693#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
3694#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
3695
3696typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
3697
3698typedef struct VkXcbSurfaceCreateInfoKHR {
3699    VkStructureType               sType;
3700    const void*                   pNext;
3701    VkXcbSurfaceCreateFlagsKHR    flags;
3702    xcb_connection_t*             connection;
3703    xcb_window_t                  window;
3704} VkXcbSurfaceCreateInfoKHR;
3705
3706
3707typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3708typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
3709
3710#ifndef VK_NO_PROTOTYPES
3711VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
3712    VkInstance                                  instance,
3713    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
3714    const VkAllocationCallbacks*                pAllocator,
3715    VkSurfaceKHR*                               pSurface);
3716
3717VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
3718    VkPhysicalDevice                            physicalDevice,
3719    uint32_t                                    queueFamilyIndex,
3720    xcb_connection_t*                           connection,
3721    xcb_visualid_t                              visual_id);
3722#endif
3723#endif /* VK_USE_PLATFORM_XCB_KHR */
3724
3725#ifdef VK_USE_PLATFORM_WAYLAND_KHR
3726#define VK_KHR_wayland_surface 1
3727#include <wayland-client.h>
3728
3729#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
3730#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
3731
3732typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
3733
3734typedef struct VkWaylandSurfaceCreateInfoKHR {
3735    VkStructureType                   sType;
3736    const void*                       pNext;
3737    VkWaylandSurfaceCreateFlagsKHR    flags;
3738    struct wl_display*                display;
3739    struct wl_surface*                surface;
3740} VkWaylandSurfaceCreateInfoKHR;
3741
3742
3743typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3744typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
3745
3746#ifndef VK_NO_PROTOTYPES
3747VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
3748    VkInstance                                  instance,
3749    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
3750    const VkAllocationCallbacks*                pAllocator,
3751    VkSurfaceKHR*                               pSurface);
3752
3753VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
3754    VkPhysicalDevice                            physicalDevice,
3755    uint32_t                                    queueFamilyIndex,
3756    struct wl_display*                          display);
3757#endif
3758#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
3759
3760#ifdef VK_USE_PLATFORM_MIR_KHR
3761#define VK_KHR_mir_surface 1
3762#include <mir_toolkit/client_types.h>
3763
3764#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
3765#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
3766
3767typedef VkFlags VkMirSurfaceCreateFlagsKHR;
3768
3769typedef struct VkMirSurfaceCreateInfoKHR {
3770    VkStructureType               sType;
3771    const void*                   pNext;
3772    VkMirSurfaceCreateFlagsKHR    flags;
3773    MirConnection*                connection;
3774    MirSurface*                   mirSurface;
3775} VkMirSurfaceCreateInfoKHR;
3776
3777
3778typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3779typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
3780
3781#ifndef VK_NO_PROTOTYPES
3782VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
3783    VkInstance                                  instance,
3784    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
3785    const VkAllocationCallbacks*                pAllocator,
3786    VkSurfaceKHR*                               pSurface);
3787
3788VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
3789    VkPhysicalDevice                            physicalDevice,
3790    uint32_t                                    queueFamilyIndex,
3791    MirConnection*                              connection);
3792#endif
3793#endif /* VK_USE_PLATFORM_MIR_KHR */
3794
3795#ifdef VK_USE_PLATFORM_ANDROID_KHR
3796#define VK_KHR_android_surface 1
3797
3798#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
3799#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
3800
3801typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
3802
3803typedef struct VkAndroidSurfaceCreateInfoKHR {
3804    VkStructureType                   sType;
3805    const void*                       pNext;
3806    VkAndroidSurfaceCreateFlagsKHR    flags;
3807    struct ANativeWindow*             window;
3808} VkAndroidSurfaceCreateInfoKHR;
3809
3810
3811typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3812
3813#ifndef VK_NO_PROTOTYPES
3814VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
3815    VkInstance                                  instance,
3816    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
3817    const VkAllocationCallbacks*                pAllocator,
3818    VkSurfaceKHR*                               pSurface);
3819#endif
3820#endif /* VK_USE_PLATFORM_ANDROID_KHR */
3821
3822#ifdef VK_USE_PLATFORM_WIN32_KHR
3823#define VK_KHR_win32_surface 1
3824#include <windows.h>
3825
3826#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5
3827#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
3828
3829typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
3830
3831typedef struct VkWin32SurfaceCreateInfoKHR {
3832    VkStructureType                 sType;
3833    const void*                     pNext;
3834    VkWin32SurfaceCreateFlagsKHR    flags;
3835    HINSTANCE                       hinstance;
3836    HWND                            hwnd;
3837} VkWin32SurfaceCreateInfoKHR;
3838
3839
3840typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
3841typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
3842
3843#ifndef VK_NO_PROTOTYPES
3844VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
3845    VkInstance                                  instance,
3846    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
3847    const VkAllocationCallbacks*                pAllocator,
3848    VkSurfaceKHR*                               pSurface);
3849
3850VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
3851    VkPhysicalDevice                            physicalDevice,
3852    uint32_t                                    queueFamilyIndex);
3853#endif
3854#endif /* VK_USE_PLATFORM_WIN32_KHR */
3855
3856#define VK_KHR_sampler_mirror_clamp_to_edge 1
3857#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
3858#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
3859
3860
3861#define VK_KHR_get_physical_device_properties2 1
3862#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
3863#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
3864
3865typedef struct VkPhysicalDeviceFeatures2KHR {
3866    VkStructureType             sType;
3867    void*                       pNext;
3868    VkPhysicalDeviceFeatures    features;
3869} VkPhysicalDeviceFeatures2KHR;
3870
3871typedef struct VkPhysicalDeviceProperties2KHR {
3872    VkStructureType               sType;
3873    void*                         pNext;
3874    VkPhysicalDeviceProperties    properties;
3875} VkPhysicalDeviceProperties2KHR;
3876
3877typedef struct VkFormatProperties2KHR {
3878    VkStructureType       sType;
3879    void*                 pNext;
3880    VkFormatProperties    formatProperties;
3881} VkFormatProperties2KHR;
3882
3883typedef struct VkImageFormatProperties2KHR {
3884    VkStructureType            sType;
3885    void*                      pNext;
3886    VkImageFormatProperties    imageFormatProperties;
3887} VkImageFormatProperties2KHR;
3888
3889typedef struct VkPhysicalDeviceImageFormatInfo2KHR {
3890    VkStructureType       sType;
3891    const void*           pNext;
3892    VkFormat              format;
3893    VkImageType           type;
3894    VkImageTiling         tiling;
3895    VkImageUsageFlags     usage;
3896    VkImageCreateFlags    flags;
3897} VkPhysicalDeviceImageFormatInfo2KHR;
3898
3899typedef struct VkQueueFamilyProperties2KHR {
3900    VkStructureType            sType;
3901    void*                      pNext;
3902    VkQueueFamilyProperties    queueFamilyProperties;
3903} VkQueueFamilyProperties2KHR;
3904
3905typedef struct VkPhysicalDeviceMemoryProperties2KHR {
3906    VkStructureType                     sType;
3907    void*                               pNext;
3908    VkPhysicalDeviceMemoryProperties    memoryProperties;
3909} VkPhysicalDeviceMemoryProperties2KHR;
3910
3911typedef struct VkSparseImageFormatProperties2KHR {
3912    VkStructureType                  sType;
3913    void*                            pNext;
3914    VkSparseImageFormatProperties    properties;
3915} VkSparseImageFormatProperties2KHR;
3916
3917typedef struct VkPhysicalDeviceSparseImageFormatInfo2KHR {
3918    VkStructureType          sType;
3919    const void*              pNext;
3920    VkFormat                 format;
3921    VkImageType              type;
3922    VkSampleCountFlagBits    samples;
3923    VkImageUsageFlags        usage;
3924    VkImageTiling            tiling;
3925} VkPhysicalDeviceSparseImageFormatInfo2KHR;
3926
3927
3928typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures);
3929typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties);
3930typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties);
3931typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties);
3932typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
3933typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
3934typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties);
3935
3936#ifndef VK_NO_PROTOTYPES
3937VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
3938    VkPhysicalDevice                            physicalDevice,
3939    VkPhysicalDeviceFeatures2KHR*               pFeatures);
3940
3941VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
3942    VkPhysicalDevice                            physicalDevice,
3943    VkPhysicalDeviceProperties2KHR*             pProperties);
3944
3945VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
3946    VkPhysicalDevice                            physicalDevice,
3947    VkFormat                                    format,
3948    VkFormatProperties2KHR*                     pFormatProperties);
3949
3950VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
3951    VkPhysicalDevice                            physicalDevice,
3952    const VkPhysicalDeviceImageFormatInfo2KHR*  pImageFormatInfo,
3953    VkImageFormatProperties2KHR*                pImageFormatProperties);
3954
3955VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
3956    VkPhysicalDevice                            physicalDevice,
3957    uint32_t*                                   pQueueFamilyPropertyCount,
3958    VkQueueFamilyProperties2KHR*                pQueueFamilyProperties);
3959
3960VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
3961    VkPhysicalDevice                            physicalDevice,
3962    VkPhysicalDeviceMemoryProperties2KHR*       pMemoryProperties);
3963
3964VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
3965    VkPhysicalDevice                            physicalDevice,
3966    const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
3967    uint32_t*                                   pPropertyCount,
3968    VkSparseImageFormatProperties2KHR*          pProperties);
3969#endif
3970
3971#define VK_KHR_shader_draw_parameters 1
3972#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
3973#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
3974
3975
3976#define VK_KHR_maintenance1 1
3977#define VK_KHR_MAINTENANCE1_SPEC_VERSION  1
3978#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
3979
3980typedef VkFlags VkCommandPoolTrimFlagsKHR;
3981
3982typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags);
3983
3984#ifndef VK_NO_PROTOTYPES
3985VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
3986    VkDevice                                    device,
3987    VkCommandPool                               commandPool,
3988    VkCommandPoolTrimFlagsKHR                   flags);
3989#endif
3990
3991#define VK_KHR_push_descriptor 1
3992#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1
3993#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
3994
3995typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
3996    VkStructureType    sType;
3997    void*              pNext;
3998    uint32_t           maxPushDescriptors;
3999} VkPhysicalDevicePushDescriptorPropertiesKHR;
4000
4001
4002typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
4003
4004#ifndef VK_NO_PROTOTYPES
4005VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
4006    VkCommandBuffer                             commandBuffer,
4007    VkPipelineBindPoint                         pipelineBindPoint,
4008    VkPipelineLayout                            layout,
4009    uint32_t                                    set,
4010    uint32_t                                    descriptorWriteCount,
4011    const VkWriteDescriptorSet*                 pDescriptorWrites);
4012#endif
4013
4014#define VK_KHR_incremental_present 1
4015#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
4016#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
4017
4018typedef struct VkRectLayerKHR {
4019    VkOffset2D    offset;
4020    VkExtent2D    extent;
4021    uint32_t      layer;
4022} VkRectLayerKHR;
4023
4024typedef struct VkPresentRegionKHR {
4025    uint32_t                 rectangleCount;
4026    const VkRectLayerKHR*    pRectangles;
4027} VkPresentRegionKHR;
4028
4029typedef struct VkPresentRegionsKHR {
4030    VkStructureType              sType;
4031    const void*                  pNext;
4032    uint32_t                     swapchainCount;
4033    const VkPresentRegionKHR*    pRegions;
4034} VkPresentRegionsKHR;
4035
4036
4037
4038#define VK_KHR_descriptor_update_template 1
4039VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR)
4040
4041#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
4042#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
4043
4044
4045typedef enum VkDescriptorUpdateTemplateTypeKHR {
4046    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0,
4047    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
4048    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
4049    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,
4050    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + 1),
4051    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
4052} VkDescriptorUpdateTemplateTypeKHR;
4053
4054typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
4055
4056typedef struct VkDescriptorUpdateTemplateEntryKHR {
4057    uint32_t            dstBinding;
4058    uint32_t            dstArrayElement;
4059    uint32_t            descriptorCount;
4060    VkDescriptorType    descriptorType;
4061    size_t              offset;
4062    size_t              stride;
4063} VkDescriptorUpdateTemplateEntryKHR;
4064
4065typedef struct VkDescriptorUpdateTemplateCreateInfoKHR {
4066    VkStructureType                              sType;
4067    void*                                        pNext;
4068    VkDescriptorUpdateTemplateCreateFlagsKHR     flags;
4069    uint32_t                                     descriptorUpdateEntryCount;
4070    const VkDescriptorUpdateTemplateEntryKHR*    pDescriptorUpdateEntries;
4071    VkDescriptorUpdateTemplateTypeKHR            templateType;
4072    VkDescriptorSetLayout                        descriptorSetLayout;
4073    VkPipelineBindPoint                          pipelineBindPoint;
4074    VkPipelineLayout                             pipelineLayout;
4075    uint32_t                                     set;
4076} VkDescriptorUpdateTemplateCreateInfoKHR;
4077
4078
4079typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
4080typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
4081typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData);
4082typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
4083
4084#ifndef VK_NO_PROTOTYPES
4085VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
4086    VkDevice                                    device,
4087    const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
4088    const VkAllocationCallbacks*                pAllocator,
4089    VkDescriptorUpdateTemplateKHR*              pDescriptorUpdateTemplate);
4090
4091VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
4092    VkDevice                                    device,
4093    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
4094    const VkAllocationCallbacks*                pAllocator);
4095
4096VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
4097    VkDevice                                    device,
4098    VkDescriptorSet                             descriptorSet,
4099    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
4100    const void*                                 pData);
4101
4102VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
4103    VkCommandBuffer                             commandBuffer,
4104    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
4105    VkPipelineLayout                            layout,
4106    uint32_t                                    set,
4107    const void*                                 pData);
4108#endif
4109
4110#define VK_EXT_debug_report 1
4111VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
4112
4113#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  6
4114#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
4115#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
4116
4117
4118typedef enum VkDebugReportObjectTypeEXT {
4119    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
4120    VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
4121    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
4122    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
4123    VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
4124    VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
4125    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
4126    VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
4127    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
4128    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
4129    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
4130    VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
4131    VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
4132    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
4133    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
4134    VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
4135    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
4136    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
4137    VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
4138    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
4139    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
4140    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
4141    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
4142    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
4143    VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
4144    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
4145    VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
4146    VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
4147    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28,
4148    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
4149    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
4150    VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
4151    VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
4152    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,
4153    VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
4154    VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
4155    VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1),
4156    VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
4157} VkDebugReportObjectTypeEXT;
4158
4159typedef enum VkDebugReportErrorEXT {
4160    VK_DEBUG_REPORT_ERROR_NONE_EXT = 0,
4161    VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1,
4162    VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_ERROR_NONE_EXT,
4163    VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT,
4164    VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT - VK_DEBUG_REPORT_ERROR_NONE_EXT + 1),
4165    VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = 0x7FFFFFFF
4166} VkDebugReportErrorEXT;
4167
4168
4169typedef enum VkDebugReportFlagBitsEXT {
4170    VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
4171    VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
4172    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
4173    VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
4174    VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
4175    VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
4176} VkDebugReportFlagBitsEXT;
4177typedef VkFlags VkDebugReportFlagsEXT;
4178
4179typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
4180    VkDebugReportFlagsEXT                       flags,
4181    VkDebugReportObjectTypeEXT                  objectType,
4182    uint64_t                                    object,
4183    size_t                                      location,
4184    int32_t                                     messageCode,
4185    const char*                                 pLayerPrefix,
4186    const char*                                 pMessage,
4187    void*                                       pUserData);
4188
4189
4190typedef struct VkDebugReportCallbackCreateInfoEXT {
4191    VkStructureType                 sType;
4192    const void*                     pNext;
4193    VkDebugReportFlagsEXT           flags;
4194    PFN_vkDebugReportCallbackEXT    pfnCallback;
4195    void*                           pUserData;
4196} VkDebugReportCallbackCreateInfoEXT;
4197
4198
4199typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
4200typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
4201typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
4202
4203#ifndef VK_NO_PROTOTYPES
4204VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
4205    VkInstance                                  instance,
4206    const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
4207    const VkAllocationCallbacks*                pAllocator,
4208    VkDebugReportCallbackEXT*                   pCallback);
4209
4210VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
4211    VkInstance                                  instance,
4212    VkDebugReportCallbackEXT                    callback,
4213    const VkAllocationCallbacks*                pAllocator);
4214
4215VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
4216    VkInstance                                  instance,
4217    VkDebugReportFlagsEXT                       flags,
4218    VkDebugReportObjectTypeEXT                  objectType,
4219    uint64_t                                    object,
4220    size_t                                      location,
4221    int32_t                                     messageCode,
4222    const char*                                 pLayerPrefix,
4223    const char*                                 pMessage);
4224#endif
4225
4226#define VK_NV_glsl_shader 1
4227#define VK_NV_GLSL_SHADER_SPEC_VERSION    1
4228#define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
4229
4230
4231#define VK_IMG_filter_cubic 1
4232#define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
4233#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
4234
4235
4236#define VK_AMD_rasterization_order 1
4237#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
4238#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
4239
4240
4241typedef enum VkRasterizationOrderAMD {
4242    VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
4243    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
4244    VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
4245    VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
4246    VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
4247    VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
4248} VkRasterizationOrderAMD;
4249
4250typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
4251    VkStructureType            sType;
4252    const void*                pNext;
4253    VkRasterizationOrderAMD    rasterizationOrder;
4254} VkPipelineRasterizationStateRasterizationOrderAMD;
4255
4256
4257
4258#define VK_AMD_shader_trinary_minmax 1
4259#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
4260#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
4261
4262
4263#define VK_AMD_shader_explicit_vertex_parameter 1
4264#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
4265#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
4266
4267
4268#define VK_EXT_debug_marker 1
4269#define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
4270#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
4271
4272typedef struct VkDebugMarkerObjectNameInfoEXT {
4273    VkStructureType               sType;
4274    const void*                   pNext;
4275    VkDebugReportObjectTypeEXT    objectType;
4276    uint64_t                      object;
4277    const char*                   pObjectName;
4278} VkDebugMarkerObjectNameInfoEXT;
4279
4280typedef struct VkDebugMarkerObjectTagInfoEXT {
4281    VkStructureType               sType;
4282    const void*                   pNext;
4283    VkDebugReportObjectTypeEXT    objectType;
4284    uint64_t                      object;
4285    uint64_t                      tagName;
4286    size_t                        tagSize;
4287    const void*                   pTag;
4288} VkDebugMarkerObjectTagInfoEXT;
4289
4290typedef struct VkDebugMarkerMarkerInfoEXT {
4291    VkStructureType    sType;
4292    const void*        pNext;
4293    const char*        pMarkerName;
4294    float              color[4];
4295} VkDebugMarkerMarkerInfoEXT;
4296
4297
4298typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo);
4299typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo);
4300typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
4301typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
4302typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
4303
4304#ifndef VK_NO_PROTOTYPES
4305VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
4306    VkDevice                                    device,
4307    VkDebugMarkerObjectTagInfoEXT*              pTagInfo);
4308
4309VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
4310    VkDevice                                    device,
4311    VkDebugMarkerObjectNameInfoEXT*             pNameInfo);
4312
4313VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
4314    VkCommandBuffer                             commandBuffer,
4315    VkDebugMarkerMarkerInfoEXT*                 pMarkerInfo);
4316
4317VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
4318    VkCommandBuffer                             commandBuffer);
4319
4320VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
4321    VkCommandBuffer                             commandBuffer,
4322    VkDebugMarkerMarkerInfoEXT*                 pMarkerInfo);
4323#endif
4324
4325#define VK_AMD_gcn_shader 1
4326#define VK_AMD_GCN_SHADER_SPEC_VERSION    1
4327#define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
4328
4329
4330#define VK_NV_dedicated_allocation 1
4331#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
4332#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
4333
4334typedef struct VkDedicatedAllocationImageCreateInfoNV {
4335    VkStructureType    sType;
4336    const void*        pNext;
4337    VkBool32           dedicatedAllocation;
4338} VkDedicatedAllocationImageCreateInfoNV;
4339
4340typedef struct VkDedicatedAllocationBufferCreateInfoNV {
4341    VkStructureType    sType;
4342    const void*        pNext;
4343    VkBool32           dedicatedAllocation;
4344} VkDedicatedAllocationBufferCreateInfoNV;
4345
4346typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
4347    VkStructureType    sType;
4348    const void*        pNext;
4349    VkImage            image;
4350    VkBuffer           buffer;
4351} VkDedicatedAllocationMemoryAllocateInfoNV;
4352
4353
4354
4355#define VK_AMD_draw_indirect_count 1
4356#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
4357#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
4358
4359typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
4360typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
4361
4362#ifndef VK_NO_PROTOTYPES
4363VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
4364    VkCommandBuffer                             commandBuffer,
4365    VkBuffer                                    buffer,
4366    VkDeviceSize                                offset,
4367    VkBuffer                                    countBuffer,
4368    VkDeviceSize                                countBufferOffset,
4369    uint32_t                                    maxDrawCount,
4370    uint32_t                                    stride);
4371
4372VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
4373    VkCommandBuffer                             commandBuffer,
4374    VkBuffer                                    buffer,
4375    VkDeviceSize                                offset,
4376    VkBuffer                                    countBuffer,
4377    VkDeviceSize                                countBufferOffset,
4378    uint32_t                                    maxDrawCount,
4379    uint32_t                                    stride);
4380#endif
4381
4382#define VK_AMD_negative_viewport_height 1
4383#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
4384#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
4385
4386
4387#define VK_AMD_gpu_shader_half_float 1
4388#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1
4389#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
4390
4391
4392#define VK_AMD_shader_ballot 1
4393#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
4394#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
4395
4396
4397#define VK_KHX_multiview 1
4398#define VK_KHX_MULTIVIEW_SPEC_VERSION     1
4399#define VK_KHX_MULTIVIEW_EXTENSION_NAME   "VK_KHX_multiview"
4400
4401typedef struct VkRenderPassMultiviewCreateInfoKHX {
4402    VkStructureType    sType;
4403    const void*        pNext;
4404    uint32_t           subpassCount;
4405    const uint32_t*    pViewMasks;
4406    uint32_t           dependencyCount;
4407    const int32_t*     pViewOffsets;
4408    uint32_t           correlationMaskCount;
4409    const uint32_t*    pCorrelationMasks;
4410} VkRenderPassMultiviewCreateInfoKHX;
4411
4412typedef struct VkPhysicalDeviceMultiviewFeaturesKHX {
4413    VkStructureType    sType;
4414    void*              pNext;
4415    VkBool32           multiview;
4416    VkBool32           multiviewGeometryShader;
4417    VkBool32           multiviewTessellationShader;
4418} VkPhysicalDeviceMultiviewFeaturesKHX;
4419
4420typedef struct VkPhysicalDeviceMultiviewPropertiesKHX {
4421    VkStructureType    sType;
4422    void*              pNext;
4423    uint32_t           maxMultiviewViewCount;
4424    uint32_t           maxMultiviewInstanceIndex;
4425} VkPhysicalDeviceMultiviewPropertiesKHX;
4426
4427
4428
4429#define VK_IMG_format_pvrtc 1
4430#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
4431#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
4432
4433
4434#define VK_NV_external_memory_capabilities 1
4435#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
4436#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
4437
4438
4439typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
4440    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
4441    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
4442    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
4443    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
4444    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
4445} VkExternalMemoryHandleTypeFlagBitsNV;
4446typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
4447
4448typedef enum VkExternalMemoryFeatureFlagBitsNV {
4449    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
4450    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
4451    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
4452    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
4453} VkExternalMemoryFeatureFlagBitsNV;
4454typedef VkFlags VkExternalMemoryFeatureFlagsNV;
4455
4456typedef struct VkExternalImageFormatPropertiesNV {
4457    VkImageFormatProperties              imageFormatProperties;
4458    VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
4459    VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
4460    VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
4461} VkExternalImageFormatPropertiesNV;
4462
4463
4464typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
4465
4466#ifndef VK_NO_PROTOTYPES
4467VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
4468    VkPhysicalDevice                            physicalDevice,
4469    VkFormat                                    format,
4470    VkImageType                                 type,
4471    VkImageTiling                               tiling,
4472    VkImageUsageFlags                           usage,
4473    VkImageCreateFlags                          flags,
4474    VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
4475    VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
4476#endif
4477
4478#define VK_NV_external_memory 1
4479#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
4480#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
4481
4482typedef struct VkExternalMemoryImageCreateInfoNV {
4483    VkStructureType                      sType;
4484    const void*                          pNext;
4485    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
4486} VkExternalMemoryImageCreateInfoNV;
4487
4488typedef struct VkExportMemoryAllocateInfoNV {
4489    VkStructureType                      sType;
4490    const void*                          pNext;
4491    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
4492} VkExportMemoryAllocateInfoNV;
4493
4494
4495
4496#ifdef VK_USE_PLATFORM_WIN32_KHR
4497#define VK_NV_external_memory_win32 1
4498#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
4499#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
4500
4501typedef struct VkImportMemoryWin32HandleInfoNV {
4502    VkStructureType                      sType;
4503    const void*                          pNext;
4504    VkExternalMemoryHandleTypeFlagsNV    handleType;
4505    HANDLE                               handle;
4506} VkImportMemoryWin32HandleInfoNV;
4507
4508typedef struct VkExportMemoryWin32HandleInfoNV {
4509    VkStructureType               sType;
4510    const void*                   pNext;
4511    const SECURITY_ATTRIBUTES*    pAttributes;
4512    DWORD                         dwAccess;
4513} VkExportMemoryWin32HandleInfoNV;
4514
4515
4516typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
4517
4518#ifndef VK_NO_PROTOTYPES
4519VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
4520    VkDevice                                    device,
4521    VkDeviceMemory                              memory,
4522    VkExternalMemoryHandleTypeFlagsNV           handleType,
4523    HANDLE*                                     pHandle);
4524#endif
4525#endif /* VK_USE_PLATFORM_WIN32_KHR */
4526
4527#ifdef VK_USE_PLATFORM_WIN32_KHR
4528#define VK_NV_win32_keyed_mutex 1
4529#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
4530#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
4531
4532typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
4533    VkStructureType          sType;
4534    const void*              pNext;
4535    uint32_t                 acquireCount;
4536    const VkDeviceMemory*    pAcquireSyncs;
4537    const uint64_t*          pAcquireKeys;
4538    const uint32_t*          pAcquireTimeoutMilliseconds;
4539    uint32_t                 releaseCount;
4540    const VkDeviceMemory*    pReleaseSyncs;
4541    const uint64_t*          pReleaseKeys;
4542} VkWin32KeyedMutexAcquireReleaseInfoNV;
4543
4544
4545#endif /* VK_USE_PLATFORM_WIN32_KHR */
4546
4547#define VK_KHX_device_group 1
4548#define VK_MAX_DEVICE_GROUP_SIZE_KHX      32
4549#define VK_KHX_DEVICE_GROUP_SPEC_VERSION  1
4550#define VK_KHX_DEVICE_GROUP_EXTENSION_NAME "VK_KHX_device_group"
4551
4552
4553typedef enum VkPeerMemoryFeatureFlagBitsKHX {
4554    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 0x00000001,
4555    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 0x00000002,
4556    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x00000004,
4557    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x00000008,
4558    VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
4559} VkPeerMemoryFeatureFlagBitsKHX;
4560typedef VkFlags VkPeerMemoryFeatureFlagsKHX;
4561
4562typedef enum VkMemoryAllocateFlagBitsKHX {
4563    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x00000001,
4564    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
4565} VkMemoryAllocateFlagBitsKHX;
4566typedef VkFlags VkMemoryAllocateFlagsKHX;
4567
4568typedef enum VkDeviceGroupPresentModeFlagBitsKHX {
4569    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 0x00000001,
4570    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 0x00000002,
4571    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 0x00000004,
4572    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x00000008,
4573    VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
4574} VkDeviceGroupPresentModeFlagBitsKHX;
4575typedef VkFlags VkDeviceGroupPresentModeFlagsKHX;
4576
4577typedef struct VkMemoryAllocateFlagsInfoKHX {
4578    VkStructureType             sType;
4579    const void*                 pNext;
4580    VkMemoryAllocateFlagsKHX    flags;
4581    uint32_t                    deviceMask;
4582} VkMemoryAllocateFlagsInfoKHX;
4583
4584typedef struct VkBindBufferMemoryInfoKHX {
4585    VkStructureType    sType;
4586    const void*        pNext;
4587    VkBuffer           buffer;
4588    VkDeviceMemory     memory;
4589    VkDeviceSize       memoryOffset;
4590    uint32_t           deviceIndexCount;
4591    const uint32_t*    pDeviceIndices;
4592} VkBindBufferMemoryInfoKHX;
4593
4594typedef struct VkBindImageMemoryInfoKHX {
4595    VkStructureType    sType;
4596    const void*        pNext;
4597    VkImage            image;
4598    VkDeviceMemory     memory;
4599    VkDeviceSize       memoryOffset;
4600    uint32_t           deviceIndexCount;
4601    const uint32_t*    pDeviceIndices;
4602    uint32_t           SFRRectCount;
4603    const VkRect2D*    pSFRRects;
4604} VkBindImageMemoryInfoKHX;
4605
4606typedef struct VkDeviceGroupRenderPassBeginInfoKHX {
4607    VkStructureType    sType;
4608    const void*        pNext;
4609    uint32_t           deviceMask;
4610    uint32_t           deviceRenderAreaCount;
4611    const VkRect2D*    pDeviceRenderAreas;
4612} VkDeviceGroupRenderPassBeginInfoKHX;
4613
4614typedef struct VkDeviceGroupCommandBufferBeginInfoKHX {
4615    VkStructureType    sType;
4616    const void*        pNext;
4617    uint32_t           deviceMask;
4618} VkDeviceGroupCommandBufferBeginInfoKHX;
4619
4620typedef struct VkDeviceGroupSubmitInfoKHX {
4621    VkStructureType    sType;
4622    const void*        pNext;
4623    uint32_t           waitSemaphoreCount;
4624    const uint32_t*    pWaitSemaphoreDeviceIndices;
4625    uint32_t           commandBufferCount;
4626    const uint32_t*    pCommandBufferDeviceMasks;
4627    uint32_t           signalSemaphoreCount;
4628    const uint32_t*    pSignalSemaphoreDeviceIndices;
4629} VkDeviceGroupSubmitInfoKHX;
4630
4631typedef struct VkDeviceGroupBindSparseInfoKHX {
4632    VkStructureType    sType;
4633    const void*        pNext;
4634    uint32_t           resourceDeviceIndex;
4635    uint32_t           memoryDeviceIndex;
4636} VkDeviceGroupBindSparseInfoKHX;
4637
4638typedef struct VkDeviceGroupPresentCapabilitiesKHX {
4639    VkStructureType                     sType;
4640    const void*                         pNext;
4641    uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX];
4642    VkDeviceGroupPresentModeFlagsKHX    modes;
4643} VkDeviceGroupPresentCapabilitiesKHX;
4644
4645typedef struct VkImageSwapchainCreateInfoKHX {
4646    VkStructureType    sType;
4647    const void*        pNext;
4648    VkSwapchainKHR     swapchain;
4649} VkImageSwapchainCreateInfoKHX;
4650
4651typedef struct VkBindImageMemorySwapchainInfoKHX {
4652    VkStructureType    sType;
4653    const void*        pNext;
4654    VkSwapchainKHR     swapchain;
4655    uint32_t           imageIndex;
4656} VkBindImageMemorySwapchainInfoKHX;
4657
4658typedef struct VkAcquireNextImageInfoKHX {
4659    VkStructureType    sType;
4660    const void*        pNext;
4661    VkSwapchainKHR     swapchain;
4662    uint64_t           timeout;
4663    VkSemaphore        semaphore;
4664    VkFence            fence;
4665    uint32_t           deviceMask;
4666} VkAcquireNextImageInfoKHX;
4667
4668typedef struct VkDeviceGroupPresentInfoKHX {
4669    VkStructureType                        sType;
4670    const void*                            pNext;
4671    uint32_t                               swapchainCount;
4672    const uint32_t*                        pDeviceMasks;
4673    VkDeviceGroupPresentModeFlagBitsKHX    mode;
4674} VkDeviceGroupPresentInfoKHX;
4675
4676typedef struct VkDeviceGroupSwapchainCreateInfoKHX {
4677    VkStructureType                     sType;
4678    const void*                         pNext;
4679    VkDeviceGroupPresentModeFlagsKHX    modes;
4680} VkDeviceGroupSwapchainCreateInfoKHX;
4681
4682
4683typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures);
4684typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHX)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHX* pBindInfos);
4685typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHX)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHX* pBindInfos);
4686typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHX)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
4687typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHX)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities);
4688typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHX)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHX* pModes);
4689typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHX)(VkDevice device, const VkAcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex);
4690typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHX)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
4691typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHX)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
4692
4693#ifndef VK_NO_PROTOTYPES
4694VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHX(
4695    VkDevice                                    device,
4696    uint32_t                                    heapIndex,
4697    uint32_t                                    localDeviceIndex,
4698    uint32_t                                    remoteDeviceIndex,
4699    VkPeerMemoryFeatureFlagsKHX*                pPeerMemoryFeatures);
4700
4701VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHX(
4702    VkDevice                                    device,
4703    uint32_t                                    bindInfoCount,
4704    const VkBindBufferMemoryInfoKHX*            pBindInfos);
4705
4706VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHX(
4707    VkDevice                                    device,
4708    uint32_t                                    bindInfoCount,
4709    const VkBindImageMemoryInfoKHX*             pBindInfos);
4710
4711VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHX(
4712    VkCommandBuffer                             commandBuffer,
4713    uint32_t                                    deviceMask);
4714
4715VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHX(
4716    VkDevice                                    device,
4717    VkDeviceGroupPresentCapabilitiesKHX*        pDeviceGroupPresentCapabilities);
4718
4719VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHX(
4720    VkDevice                                    device,
4721    VkSurfaceKHR                                surface,
4722    VkDeviceGroupPresentModeFlagsKHX*           pModes);
4723
4724VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHX(
4725    VkDevice                                    device,
4726    const VkAcquireNextImageInfoKHX*            pAcquireInfo,
4727    uint32_t*                                   pImageIndex);
4728
4729VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHX(
4730    VkCommandBuffer                             commandBuffer,
4731    uint32_t                                    baseGroupX,
4732    uint32_t                                    baseGroupY,
4733    uint32_t                                    baseGroupZ,
4734    uint32_t                                    groupCountX,
4735    uint32_t                                    groupCountY,
4736    uint32_t                                    groupCountZ);
4737
4738VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX(
4739    VkPhysicalDevice                            physicalDevice,
4740    VkSurfaceKHR                                surface,
4741    uint32_t*                                   pRectCount,
4742    VkRect2D*                                   pRects);
4743#endif
4744
4745#define VK_EXT_validation_flags 1
4746#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
4747#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
4748
4749
4750typedef enum VkValidationCheckEXT {
4751    VK_VALIDATION_CHECK_ALL_EXT = 0,
4752    VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
4753    VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
4754    VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_ALL_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1),
4755    VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
4756} VkValidationCheckEXT;
4757
4758typedef struct VkValidationFlagsEXT {
4759    VkStructureType          sType;
4760    const void*              pNext;
4761    uint32_t                 disabledValidationCheckCount;
4762    VkValidationCheckEXT*    pDisabledValidationChecks;
4763} VkValidationFlagsEXT;
4764
4765
4766
4767#ifdef VK_USE_PLATFORM_VI_NN
4768#define VK_NN_vi_surface 1
4769#define VK_NN_VI_SURFACE_SPEC_VERSION     1
4770#define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
4771
4772typedef VkFlags VkViSurfaceCreateFlagsNN;
4773
4774typedef struct VkViSurfaceCreateInfoNN {
4775    VkStructureType             sType;
4776    const void*                 pNext;
4777    VkViSurfaceCreateFlagsNN    flags;
4778    void*                       window;
4779} VkViSurfaceCreateInfoNN;
4780
4781
4782typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
4783
4784#ifndef VK_NO_PROTOTYPES
4785VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
4786    VkInstance                                  instance,
4787    const VkViSurfaceCreateInfoNN*              pCreateInfo,
4788    const VkAllocationCallbacks*                pAllocator,
4789    VkSurfaceKHR*                               pSurface);
4790#endif
4791#endif /* VK_USE_PLATFORM_VI_NN */
4792
4793#define VK_EXT_shader_subgroup_ballot 1
4794#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
4795#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
4796
4797
4798#define VK_EXT_shader_subgroup_vote 1
4799#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
4800#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
4801
4802
4803#define VK_KHX_device_group_creation 1
4804#define VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION 1
4805#define VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHX_device_group_creation"
4806
4807typedef struct VkPhysicalDeviceGroupPropertiesKHX {
4808    VkStructureType     sType;
4809    void*               pNext;
4810    uint32_t            physicalDeviceCount;
4811    VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX];
4812    VkBool32            subsetAllocation;
4813} VkPhysicalDeviceGroupPropertiesKHX;
4814
4815typedef struct VkDeviceGroupDeviceCreateInfoKHX {
4816    VkStructureType            sType;
4817    const void*                pNext;
4818    uint32_t                   physicalDeviceCount;
4819    const VkPhysicalDevice*    pPhysicalDevices;
4820} VkDeviceGroupDeviceCreateInfoKHX;
4821
4822
4823typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHX)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties);
4824
4825#ifndef VK_NO_PROTOTYPES
4826VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX(
4827    VkInstance                                  instance,
4828    uint32_t*                                   pPhysicalDeviceGroupCount,
4829    VkPhysicalDeviceGroupPropertiesKHX*         pPhysicalDeviceGroupProperties);
4830#endif
4831
4832#define VK_KHX_external_memory_capabilities 1
4833#define VK_LUID_SIZE_KHX                  8
4834#define VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
4835#define VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHX_external_memory_capabilities"
4836
4837
4838typedef enum VkExternalMemoryHandleTypeFlagBitsKHX {
4839    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001,
4840    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002,
4841    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004,
4842    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX = 0x00000008,
4843    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX = 0x00000010,
4844    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX = 0x00000020,
4845    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX = 0x00000040,
4846    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
4847} VkExternalMemoryHandleTypeFlagBitsKHX;
4848typedef VkFlags VkExternalMemoryHandleTypeFlagsKHX;
4849
4850typedef enum VkExternalMemoryFeatureFlagBitsKHX {
4851    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX = 0x00000001,
4852    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX = 0x00000002,
4853    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX = 0x00000004,
4854    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
4855} VkExternalMemoryFeatureFlagBitsKHX;
4856typedef VkFlags VkExternalMemoryFeatureFlagsKHX;
4857
4858typedef struct VkExternalMemoryPropertiesKHX {
4859    VkExternalMemoryFeatureFlagsKHX       externalMemoryFeatures;
4860    VkExternalMemoryHandleTypeFlagsKHX    exportFromImportedHandleTypes;
4861    VkExternalMemoryHandleTypeFlagsKHX    compatibleHandleTypes;
4862} VkExternalMemoryPropertiesKHX;
4863
4864typedef struct VkPhysicalDeviceExternalImageFormatInfoKHX {
4865    VkStructureType                          sType;
4866    const void*                              pNext;
4867    VkExternalMemoryHandleTypeFlagBitsKHX    handleType;
4868} VkPhysicalDeviceExternalImageFormatInfoKHX;
4869
4870typedef struct VkExternalImageFormatPropertiesKHX {
4871    VkStructureType                  sType;
4872    void*                            pNext;
4873    VkExternalMemoryPropertiesKHX    externalMemoryProperties;
4874} VkExternalImageFormatPropertiesKHX;
4875
4876typedef struct VkPhysicalDeviceExternalBufferInfoKHX {
4877    VkStructureType                          sType;
4878    const void*                              pNext;
4879    VkBufferCreateFlags                      flags;
4880    VkBufferUsageFlags                       usage;
4881    VkExternalMemoryHandleTypeFlagBitsKHX    handleType;
4882} VkPhysicalDeviceExternalBufferInfoKHX;
4883
4884typedef struct VkExternalBufferPropertiesKHX {
4885    VkStructureType                  sType;
4886    void*                            pNext;
4887    VkExternalMemoryPropertiesKHX    externalMemoryProperties;
4888} VkExternalBufferPropertiesKHX;
4889
4890typedef struct VkPhysicalDeviceIDPropertiesKHX {
4891    VkStructureType    sType;
4892    void*              pNext;
4893    uint8_t            deviceUUID[VK_UUID_SIZE];
4894    uint8_t            driverUUID[VK_UUID_SIZE];
4895    uint8_t            deviceLUID[VK_LUID_SIZE_KHX];
4896    VkBool32           deviceLUIDValid;
4897} VkPhysicalDeviceIDPropertiesKHX;
4898
4899
4900typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties);
4901
4902#ifndef VK_NO_PROTOTYPES
4903VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHX(
4904    VkPhysicalDevice                            physicalDevice,
4905    const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo,
4906    VkExternalBufferPropertiesKHX*              pExternalBufferProperties);
4907#endif
4908
4909#define VK_KHX_external_memory 1
4910#define VK_KHX_EXTERNAL_MEMORY_SPEC_VERSION 1
4911#define VK_KHX_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHX_external_memory"
4912#define VK_QUEUE_FAMILY_EXTERNAL_KHX      (~0U-1)
4913
4914typedef struct VkExternalMemoryImageCreateInfoKHX {
4915    VkStructureType                       sType;
4916    const void*                           pNext;
4917    VkExternalMemoryHandleTypeFlagsKHX    handleTypes;
4918} VkExternalMemoryImageCreateInfoKHX;
4919
4920typedef struct VkExternalMemoryBufferCreateInfoKHX {
4921    VkStructureType                       sType;
4922    const void*                           pNext;
4923    VkExternalMemoryHandleTypeFlagsKHX    handleTypes;
4924} VkExternalMemoryBufferCreateInfoKHX;
4925
4926typedef struct VkExportMemoryAllocateInfoKHX {
4927    VkStructureType                       sType;
4928    const void*                           pNext;
4929    VkExternalMemoryHandleTypeFlagsKHX    handleTypes;
4930} VkExportMemoryAllocateInfoKHX;
4931
4932
4933
4934#ifdef VK_USE_PLATFORM_WIN32_KHX
4935#define VK_KHX_external_memory_win32 1
4936#define VK_KHX_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
4937#define VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHX_external_memory_win32"
4938
4939typedef struct VkImportMemoryWin32HandleInfoKHX {
4940    VkStructureType                          sType;
4941    const void*                              pNext;
4942    VkExternalMemoryHandleTypeFlagBitsKHX    handleType;
4943    HANDLE                                   handle;
4944} VkImportMemoryWin32HandleInfoKHX;
4945
4946typedef struct VkExportMemoryWin32HandleInfoKHX {
4947    VkStructureType               sType;
4948    const void*                   pNext;
4949    const SECURITY_ATTRIBUTES*    pAttributes;
4950    DWORD                         dwAccess;
4951    LPCWSTR                       name;
4952} VkExportMemoryWin32HandleInfoKHX;
4953
4954typedef struct VkMemoryWin32HandlePropertiesKHX {
4955    VkStructureType    sType;
4956    void*              pNext;
4957    uint32_t           memoryTypeBits;
4958} VkMemoryWin32HandlePropertiesKHX;
4959
4960
4961typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHX)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle);
4962typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHX)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties);
4963
4964#ifndef VK_NO_PROTOTYPES
4965VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHX(
4966    VkDevice                                    device,
4967    VkDeviceMemory                              memory,
4968    VkExternalMemoryHandleTypeFlagBitsKHX       handleType,
4969    HANDLE*                                     pHandle);
4970
4971VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHX(
4972    VkDevice                                    device,
4973    VkExternalMemoryHandleTypeFlagBitsKHX       handleType,
4974    HANDLE                                      handle,
4975    VkMemoryWin32HandlePropertiesKHX*           pMemoryWin32HandleProperties);
4976#endif
4977#endif /* VK_USE_PLATFORM_WIN32_KHX */
4978
4979#define VK_KHX_external_memory_fd 1
4980#define VK_KHX_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
4981#define VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHX_external_memory_fd"
4982
4983typedef struct VkImportMemoryFdInfoKHX {
4984    VkStructureType                          sType;
4985    const void*                              pNext;
4986    VkExternalMemoryHandleTypeFlagBitsKHX    handleType;
4987    int                                      fd;
4988} VkImportMemoryFdInfoKHX;
4989
4990typedef struct VkMemoryFdPropertiesKHX {
4991    VkStructureType    sType;
4992    void*              pNext;
4993    uint32_t           memoryTypeBits;
4994} VkMemoryFdPropertiesKHX;
4995
4996
4997typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHX)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd);
4998typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHX)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, VkMemoryFdPropertiesKHX* pMemoryFdProperties);
4999
5000#ifndef VK_NO_PROTOTYPES
5001VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHX(
5002    VkDevice                                    device,
5003    VkDeviceMemory                              memory,
5004    VkExternalMemoryHandleTypeFlagBitsKHX       handleType,
5005    int*                                        pFd);
5006
5007VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHX(
5008    VkDevice                                    device,
5009    VkExternalMemoryHandleTypeFlagBitsKHX       handleType,
5010    int                                         fd,
5011    VkMemoryFdPropertiesKHX*                    pMemoryFdProperties);
5012#endif
5013
5014#ifdef VK_USE_PLATFORM_WIN32_KHR
5015#define VK_KHX_win32_keyed_mutex 1
5016#define VK_KHX_WIN32_KEYED_MUTEX_SPEC_VERSION 1
5017#define VK_KHX_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHX_win32_keyed_mutex"
5018
5019typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHX {
5020    VkStructureType          sType;
5021    const void*              pNext;
5022    uint32_t                 acquireCount;
5023    const VkDeviceMemory*    pAcquireSyncs;
5024    const uint64_t*          pAcquireKeys;
5025    const uint32_t*          pAcquireTimeouts;
5026    uint32_t                 releaseCount;
5027    const VkDeviceMemory*    pReleaseSyncs;
5028    const uint64_t*          pReleaseKeys;
5029} VkWin32KeyedMutexAcquireReleaseInfoKHX;
5030
5031
5032#endif /* VK_USE_PLATFORM_WIN32_KHR */
5033
5034#define VK_KHX_external_semaphore_capabilities 1
5035#define VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
5036#define VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHX_external_semaphore_capabilities"
5037
5038
5039typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHX {
5040    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001,
5041    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002,
5042    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004,
5043    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX = 0x00000008,
5044    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX = 0x00000010,
5045    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
5046} VkExternalSemaphoreHandleTypeFlagBitsKHX;
5047typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHX;
5048
5049typedef enum VkExternalSemaphoreFeatureFlagBitsKHX {
5050    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX = 0x00000001,
5051    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX = 0x00000002,
5052    VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
5053} VkExternalSemaphoreFeatureFlagBitsKHX;
5054typedef VkFlags VkExternalSemaphoreFeatureFlagsKHX;
5055
5056typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHX {
5057    VkStructureType                             sType;
5058    const void*                                 pNext;
5059    VkExternalSemaphoreHandleTypeFlagBitsKHX    handleType;
5060} VkPhysicalDeviceExternalSemaphoreInfoKHX;
5061
5062typedef struct VkExternalSemaphorePropertiesKHX {
5063    VkStructureType                          sType;
5064    void*                                    pNext;
5065    VkExternalSemaphoreHandleTypeFlagsKHX    exportFromImportedHandleTypes;
5066    VkExternalSemaphoreHandleTypeFlagsKHX    compatibleHandleTypes;
5067    VkExternalSemaphoreFeatureFlagsKHX       externalSemaphoreFeatures;
5068} VkExternalSemaphorePropertiesKHX;
5069
5070
5071typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties);
5072
5073#ifndef VK_NO_PROTOTYPES
5074VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(
5075    VkPhysicalDevice                            physicalDevice,
5076    const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo,
5077    VkExternalSemaphorePropertiesKHX*           pExternalSemaphoreProperties);
5078#endif
5079
5080#define VK_KHX_external_semaphore 1
5081#define VK_KHX_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
5082#define VK_KHX_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHX_external_semaphore"
5083
5084typedef struct VkExportSemaphoreCreateInfoKHX {
5085    VkStructureType                          sType;
5086    const void*                              pNext;
5087    VkExternalSemaphoreHandleTypeFlagsKHX    handleTypes;
5088} VkExportSemaphoreCreateInfoKHX;
5089
5090
5091
5092#ifdef VK_USE_PLATFORM_WIN32_KHX
5093#define VK_KHX_external_semaphore_win32 1
5094#define VK_KHX_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
5095#define VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHX_external_semaphore_win32"
5096
5097typedef struct VkImportSemaphoreWin32HandleInfoKHX {
5098    VkStructureType                          sType;
5099    const void*                              pNext;
5100    VkSemaphore                              semaphore;
5101    VkExternalSemaphoreHandleTypeFlagsKHX    handleType;
5102    HANDLE                                   handle;
5103} VkImportSemaphoreWin32HandleInfoKHX;
5104
5105typedef struct VkExportSemaphoreWin32HandleInfoKHX {
5106    VkStructureType               sType;
5107    const void*                   pNext;
5108    const SECURITY_ATTRIBUTES*    pAttributes;
5109    DWORD                         dwAccess;
5110    LPCWSTR                       name;
5111} VkExportSemaphoreWin32HandleInfoKHX;
5112
5113typedef struct VkD3D12FenceSubmitInfoKHX {
5114    VkStructureType    sType;
5115    const void*        pNext;
5116    uint32_t           waitSemaphoreValuesCount;
5117    const uint64_t*    pWaitSemaphoreValues;
5118    uint32_t           signalSemaphoreValuesCount;
5119    const uint64_t*    pSignalSemaphoreValues;
5120} VkD3D12FenceSubmitInfoKHX;
5121
5122
5123typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHX)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo);
5124typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHX)(VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle);
5125
5126#ifndef VK_NO_PROTOTYPES
5127VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHX(
5128    VkDevice                                    device,
5129    const VkImportSemaphoreWin32HandleInfoKHX*  pImportSemaphoreWin32HandleInfo);
5130
5131VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHX(
5132    VkDevice                                    device,
5133    VkSemaphore                                 semaphore,
5134    VkExternalSemaphoreHandleTypeFlagBitsKHX    handleType,
5135    HANDLE*                                     pHandle);
5136#endif
5137#endif /* VK_USE_PLATFORM_WIN32_KHX */
5138
5139#define VK_KHX_external_semaphore_fd 1
5140#define VK_KHX_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
5141#define VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHX_external_semaphore_fd"
5142
5143typedef struct VkImportSemaphoreFdInfoKHX {
5144    VkStructureType                             sType;
5145    const void*                                 pNext;
5146    VkSemaphore                                 semaphore;
5147    VkExternalSemaphoreHandleTypeFlagBitsKHX    handleType;
5148    int                                         fd;
5149} VkImportSemaphoreFdInfoKHX;
5150
5151
5152typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHX)(VkDevice device, const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo);
5153typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHX)(VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd);
5154
5155#ifndef VK_NO_PROTOTYPES
5156VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHX(
5157    VkDevice                                    device,
5158    const VkImportSemaphoreFdInfoKHX*           pImportSemaphoreFdInfo);
5159
5160VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHX(
5161    VkDevice                                    device,
5162    VkSemaphore                                 semaphore,
5163    VkExternalSemaphoreHandleTypeFlagBitsKHX    handleType,
5164    int*                                        pFd);
5165#endif
5166
5167#define VK_NVX_device_generated_commands 1
5168VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
5169VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
5170
5171#define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1
5172#define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
5173
5174
5175typedef enum VkIndirectCommandsTokenTypeNVX {
5176    VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = 0,
5177    VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = 1,
5178    VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = 2,
5179    VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = 3,
5180    VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = 4,
5181    VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = 5,
5182    VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = 6,
5183    VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = 7,
5184    VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX,
5185    VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX,
5186    VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX + 1),
5187    VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
5188} VkIndirectCommandsTokenTypeNVX;
5189
5190typedef enum VkObjectEntryTypeNVX {
5191    VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0,
5192    VK_OBJECT_ENTRY_PIPELINE_NVX = 1,
5193    VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2,
5194    VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3,
5195    VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4,
5196    VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX,
5197    VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX,
5198    VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX + 1),
5199    VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
5200} VkObjectEntryTypeNVX;
5201
5202
5203typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
5204    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
5205    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
5206    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
5207    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
5208    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
5209} VkIndirectCommandsLayoutUsageFlagBitsNVX;
5210typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
5211
5212typedef enum VkObjectEntryUsageFlagBitsNVX {
5213    VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
5214    VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
5215    VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
5216} VkObjectEntryUsageFlagBitsNVX;
5217typedef VkFlags VkObjectEntryUsageFlagsNVX;
5218
5219typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
5220    VkStructureType    sType;
5221    const void*        pNext;
5222    VkBool32           computeBindingPointSupport;
5223} VkDeviceGeneratedCommandsFeaturesNVX;
5224
5225typedef struct VkDeviceGeneratedCommandsLimitsNVX {
5226    VkStructureType    sType;
5227    const void*        pNext;
5228    uint32_t           maxIndirectCommandsLayoutTokenCount;
5229    uint32_t           maxObjectEntryCounts;
5230    uint32_t           minSequenceCountBufferOffsetAlignment;
5231    uint32_t           minSequenceIndexBufferOffsetAlignment;
5232    uint32_t           minCommandsTokenBufferOffsetAlignment;
5233} VkDeviceGeneratedCommandsLimitsNVX;
5234
5235typedef struct VkIndirectCommandsTokenNVX {
5236    VkIndirectCommandsTokenTypeNVX    tokenType;
5237    VkBuffer                          buffer;
5238    VkDeviceSize                      offset;
5239} VkIndirectCommandsTokenNVX;
5240
5241typedef struct VkIndirectCommandsLayoutTokenNVX {
5242    VkIndirectCommandsTokenTypeNVX    tokenType;
5243    uint32_t                          bindingUnit;
5244    uint32_t                          dynamicCount;
5245    uint32_t                          divisor;
5246} VkIndirectCommandsLayoutTokenNVX;
5247
5248typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
5249    VkStructureType                            sType;
5250    const void*                                pNext;
5251    VkPipelineBindPoint                        pipelineBindPoint;
5252    VkIndirectCommandsLayoutUsageFlagsNVX      flags;
5253    uint32_t                                   tokenCount;
5254    const VkIndirectCommandsLayoutTokenNVX*    pTokens;
5255} VkIndirectCommandsLayoutCreateInfoNVX;
5256
5257typedef struct VkCmdProcessCommandsInfoNVX {
5258    VkStructureType                      sType;
5259    const void*                          pNext;
5260    VkObjectTableNVX                     objectTable;
5261    VkIndirectCommandsLayoutNVX          indirectCommandsLayout;
5262    uint32_t                             indirectCommandsTokenCount;
5263    const VkIndirectCommandsTokenNVX*    pIndirectCommandsTokens;
5264    uint32_t                             maxSequencesCount;
5265    VkCommandBuffer                      targetCommandBuffer;
5266    VkBuffer                             sequencesCountBuffer;
5267    VkDeviceSize                         sequencesCountOffset;
5268    VkBuffer                             sequencesIndexBuffer;
5269    VkDeviceSize                         sequencesIndexOffset;
5270} VkCmdProcessCommandsInfoNVX;
5271
5272typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
5273    VkStructureType                sType;
5274    const void*                    pNext;
5275    VkObjectTableNVX               objectTable;
5276    VkIndirectCommandsLayoutNVX    indirectCommandsLayout;
5277    uint32_t                       maxSequencesCount;
5278} VkCmdReserveSpaceForCommandsInfoNVX;
5279
5280typedef struct VkObjectTableCreateInfoNVX {
5281    VkStructureType                      sType;
5282    const void*                          pNext;
5283    uint32_t                             objectCount;
5284    const VkObjectEntryTypeNVX*          pObjectEntryTypes;
5285    const uint32_t*                      pObjectEntryCounts;
5286    const VkObjectEntryUsageFlagsNVX*    pObjectEntryUsageFlags;
5287    uint32_t                             maxUniformBuffersPerDescriptor;
5288    uint32_t                             maxStorageBuffersPerDescriptor;
5289    uint32_t                             maxStorageImagesPerDescriptor;
5290    uint32_t                             maxSampledImagesPerDescriptor;
5291    uint32_t                             maxPipelineLayouts;
5292} VkObjectTableCreateInfoNVX;
5293
5294typedef struct VkObjectTableEntryNVX {
5295    VkObjectEntryTypeNVX          type;
5296    VkObjectEntryUsageFlagsNVX    flags;
5297} VkObjectTableEntryNVX;
5298
5299typedef struct VkObjectTablePipelineEntryNVX {
5300    VkObjectEntryTypeNVX          type;
5301    VkObjectEntryUsageFlagsNVX    flags;
5302    VkPipeline                    pipeline;
5303} VkObjectTablePipelineEntryNVX;
5304
5305typedef struct VkObjectTableDescriptorSetEntryNVX {
5306    VkObjectEntryTypeNVX          type;
5307    VkObjectEntryUsageFlagsNVX    flags;
5308    VkPipelineLayout              pipelineLayout;
5309    VkDescriptorSet               descriptorSet;
5310} VkObjectTableDescriptorSetEntryNVX;
5311
5312typedef struct VkObjectTableVertexBufferEntryNVX {
5313    VkObjectEntryTypeNVX          type;
5314    VkObjectEntryUsageFlagsNVX    flags;
5315    VkBuffer                      buffer;
5316} VkObjectTableVertexBufferEntryNVX;
5317
5318typedef struct VkObjectTableIndexBufferEntryNVX {
5319    VkObjectEntryTypeNVX          type;
5320    VkObjectEntryUsageFlagsNVX    flags;
5321    VkBuffer                      buffer;
5322    VkIndexType                   indexType;
5323} VkObjectTableIndexBufferEntryNVX;
5324
5325typedef struct VkObjectTablePushConstantEntryNVX {
5326    VkObjectEntryTypeNVX          type;
5327    VkObjectEntryUsageFlagsNVX    flags;
5328    VkPipelineLayout              pipelineLayout;
5329    VkShaderStageFlags            stageFlags;
5330} VkObjectTablePushConstantEntryNVX;
5331
5332
5333typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
5334typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
5335typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
5336typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
5337typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
5338typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
5339typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const*    ppObjectTableEntries, const uint32_t* pObjectIndices);
5340typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices);
5341typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
5342
5343#ifndef VK_NO_PROTOTYPES
5344VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
5345    VkCommandBuffer                             commandBuffer,
5346    const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
5347
5348VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
5349    VkCommandBuffer                             commandBuffer,
5350    const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
5351
5352VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
5353    VkDevice                                    device,
5354    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
5355    const VkAllocationCallbacks*                pAllocator,
5356    VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
5357
5358VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
5359    VkDevice                                    device,
5360    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
5361    const VkAllocationCallbacks*                pAllocator);
5362
5363VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
5364    VkDevice                                    device,
5365    const VkObjectTableCreateInfoNVX*           pCreateInfo,
5366    const VkAllocationCallbacks*                pAllocator,
5367    VkObjectTableNVX*                           pObjectTable);
5368
5369VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(
5370    VkDevice                                    device,
5371    VkObjectTableNVX                            objectTable,
5372    const VkAllocationCallbacks*                pAllocator);
5373
5374VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
5375    VkDevice                                    device,
5376    VkObjectTableNVX                            objectTable,
5377    uint32_t                                    objectCount,
5378    const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
5379    const uint32_t*                             pObjectIndices);
5380
5381VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
5382    VkDevice                                    device,
5383    VkObjectTableNVX                            objectTable,
5384    uint32_t                                    objectCount,
5385    const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
5386    const uint32_t*                             pObjectIndices);
5387
5388VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
5389    VkPhysicalDevice                            physicalDevice,
5390    VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
5391    VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
5392#endif
5393
5394#define VK_NV_clip_space_w_scaling 1
5395#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
5396#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
5397
5398typedef struct VkViewportWScalingNV {
5399    float    xcoeff;
5400    float    ycoeff;
5401} VkViewportWScalingNV;
5402
5403typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
5404    VkStructureType                sType;
5405    const void*                    pNext;
5406    VkBool32                       viewportWScalingEnable;
5407    uint32_t                       viewportCount;
5408    const VkViewportWScalingNV*    pViewportWScalings;
5409} VkPipelineViewportWScalingStateCreateInfoNV;
5410
5411
5412typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
5413
5414#ifndef VK_NO_PROTOTYPES
5415VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
5416    VkCommandBuffer                             commandBuffer,
5417    uint32_t                                    firstViewport,
5418    uint32_t                                    viewportCount,
5419    const VkViewportWScalingNV*                 pViewportWScalings);
5420#endif
5421
5422#define VK_EXT_direct_mode_display 1
5423#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
5424#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
5425
5426typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
5427
5428#ifndef VK_NO_PROTOTYPES
5429VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
5430    VkPhysicalDevice                            physicalDevice,
5431    VkDisplayKHR                                display);
5432#endif
5433
5434#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
5435#define VK_EXT_acquire_xlib_display 1
5436#include <X11/extensions/Xrandr.h>
5437
5438#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
5439#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
5440
5441typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
5442typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
5443
5444#ifndef VK_NO_PROTOTYPES
5445VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
5446    VkPhysicalDevice                            physicalDevice,
5447    Display*                                    dpy,
5448    VkDisplayKHR                                display);
5449
5450VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
5451    VkPhysicalDevice                            physicalDevice,
5452    Display*                                    dpy,
5453    RROutput                                    rrOutput,
5454    VkDisplayKHR*                               pDisplay);
5455#endif
5456#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
5457
5458#define VK_EXT_display_surface_counter 1
5459#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
5460#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
5461
5462
5463typedef enum VkSurfaceCounterFlagBitsEXT {
5464    VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001,
5465    VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
5466} VkSurfaceCounterFlagBitsEXT;
5467typedef VkFlags VkSurfaceCounterFlagsEXT;
5468
5469typedef struct VkSurfaceCapabilities2EXT {
5470    VkStructureType                  sType;
5471    void*                            pNext;
5472    uint32_t                         minImageCount;
5473    uint32_t                         maxImageCount;
5474    VkExtent2D                       currentExtent;
5475    VkExtent2D                       minImageExtent;
5476    VkExtent2D                       maxImageExtent;
5477    uint32_t                         maxImageArrayLayers;
5478    VkSurfaceTransformFlagsKHR       supportedTransforms;
5479    VkSurfaceTransformFlagBitsKHR    currentTransform;
5480    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
5481    VkImageUsageFlags                supportedUsageFlags;
5482    VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
5483} VkSurfaceCapabilities2EXT;
5484
5485
5486typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
5487
5488#ifndef VK_NO_PROTOTYPES
5489VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
5490    VkPhysicalDevice                            physicalDevice,
5491    VkSurfaceKHR                                surface,
5492    VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
5493#endif
5494
5495#define VK_EXT_display_control 1
5496#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
5497#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
5498
5499
5500typedef enum VkDisplayPowerStateEXT {
5501    VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
5502    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
5503    VK_DISPLAY_POWER_STATE_ON_EXT = 2,
5504    VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT,
5505    VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT,
5506    VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1),
5507    VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
5508} VkDisplayPowerStateEXT;
5509
5510typedef enum VkDeviceEventTypeEXT {
5511    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
5512    VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
5513    VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
5514    VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1),
5515    VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
5516} VkDeviceEventTypeEXT;
5517
5518typedef enum VkDisplayEventTypeEXT {
5519    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
5520    VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
5521    VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
5522    VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1),
5523    VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
5524} VkDisplayEventTypeEXT;
5525
5526typedef struct VkDisplayPowerInfoEXT {
5527    VkStructureType           sType;
5528    const void*               pNext;
5529    VkDisplayPowerStateEXT    powerState;
5530} VkDisplayPowerInfoEXT;
5531
5532typedef struct VkDeviceEventInfoEXT {
5533    VkStructureType         sType;
5534    const void*             pNext;
5535    VkDeviceEventTypeEXT    deviceEvent;
5536} VkDeviceEventInfoEXT;
5537
5538typedef struct VkDisplayEventInfoEXT {
5539    VkStructureType          sType;
5540    const void*              pNext;
5541    VkDisplayEventTypeEXT    displayEvent;
5542} VkDisplayEventInfoEXT;
5543
5544typedef struct VkSwapchainCounterCreateInfoEXT {
5545    VkStructureType             sType;
5546    const void*                 pNext;
5547    VkSurfaceCounterFlagsEXT    surfaceCounters;
5548} VkSwapchainCounterCreateInfoEXT;
5549
5550
5551typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
5552typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
5553typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
5554typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
5555
5556#ifndef VK_NO_PROTOTYPES
5557VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
5558    VkDevice                                    device,
5559    VkDisplayKHR                                display,
5560    const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
5561
5562VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
5563    VkDevice                                    device,
5564    const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
5565    const VkAllocationCallbacks*                pAllocator,
5566    VkFence*                                    pFence);
5567
5568VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
5569    VkDevice                                    device,
5570    VkDisplayKHR                                display,
5571    const VkDisplayEventInfoEXT*                pDisplayEventInfo,
5572    const VkAllocationCallbacks*                pAllocator,
5573    VkFence*                                    pFence);
5574
5575VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
5576    VkDevice                                    device,
5577    VkSwapchainKHR                              swapchain,
5578    VkSurfaceCounterFlagBitsEXT                 counter,
5579    uint64_t*                                   pCounterValue);
5580#endif
5581
5582#define VK_GOOGLE_display_timing 1
5583#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
5584#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
5585
5586typedef struct VkRefreshCycleDurationGOOGLE {
5587    uint64_t    refreshDuration;
5588} VkRefreshCycleDurationGOOGLE;
5589
5590typedef struct VkPastPresentationTimingGOOGLE {
5591    uint32_t    presentID;
5592    uint64_t    desiredPresentTime;
5593    uint64_t    actualPresentTime;
5594    uint64_t    earliestPresentTime;
5595    uint64_t    presentMargin;
5596} VkPastPresentationTimingGOOGLE;
5597
5598typedef struct VkPresentTimeGOOGLE {
5599    uint32_t    presentID;
5600    uint64_t    desiredPresentTime;
5601} VkPresentTimeGOOGLE;
5602
5603typedef struct VkPresentTimesInfoGOOGLE {
5604    VkStructureType               sType;
5605    const void*                   pNext;
5606    uint32_t                      swapchainCount;
5607    const VkPresentTimeGOOGLE*    pTimes;
5608} VkPresentTimesInfoGOOGLE;
5609
5610
5611typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
5612typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
5613
5614#ifndef VK_NO_PROTOTYPES
5615VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
5616    VkDevice                                    device,
5617    VkSwapchainKHR                              swapchain,
5618    VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
5619
5620VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
5621    VkDevice                                    device,
5622    VkSwapchainKHR                              swapchain,
5623    uint32_t*                                   pPresentationTimingCount,
5624    VkPastPresentationTimingGOOGLE*             pPresentationTimings);
5625#endif
5626
5627#define VK_NV_sample_mask_override_coverage 1
5628#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
5629#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
5630
5631
5632#define VK_NV_geometry_shader_passthrough 1
5633#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
5634#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
5635
5636
5637#define VK_NV_viewport_array2 1
5638#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
5639#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
5640
5641
5642#define VK_NVX_multiview_per_view_attributes 1
5643#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
5644#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
5645
5646typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
5647    VkStructureType    sType;
5648    void*              pNext;
5649    VkBool32           perViewPositionAllComponents;
5650} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
5651
5652
5653
5654#define VK_NV_viewport_swizzle 1
5655#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
5656#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
5657
5658
5659typedef enum VkViewportCoordinateSwizzleNV {
5660    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
5661    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
5662    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
5663    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
5664    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
5665    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
5666    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
5667    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
5668    VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
5669    VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV,
5670    VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1),
5671    VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
5672} VkViewportCoordinateSwizzleNV;
5673
5674typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
5675
5676typedef struct VkViewportSwizzleNV {
5677    VkViewportCoordinateSwizzleNV    x;
5678    VkViewportCoordinateSwizzleNV    y;
5679    VkViewportCoordinateSwizzleNV    z;
5680    VkViewportCoordinateSwizzleNV    w;
5681} VkViewportSwizzleNV;
5682
5683typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
5684    VkStructureType                                sType;
5685    const void*                                    pNext;
5686    VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
5687    uint32_t                                       viewportCount;
5688    const VkViewportSwizzleNV*                     pViewportSwizzles;
5689} VkPipelineViewportSwizzleStateCreateInfoNV;
5690
5691
5692
5693#define VK_EXT_discard_rectangles 1
5694#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
5695#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
5696
5697
5698typedef enum VkDiscardRectangleModeEXT {
5699    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
5700    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
5701    VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
5702    VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT,
5703    VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1),
5704    VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
5705} VkDiscardRectangleModeEXT;
5706
5707typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
5708
5709typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
5710    VkStructureType    sType;
5711    void*              pNext;
5712    uint32_t           maxDiscardRectangles;
5713} VkPhysicalDeviceDiscardRectanglePropertiesEXT;
5714
5715typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
5716    VkStructureType                                  sType;
5717    const void*                                      pNext;
5718    VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
5719    VkDiscardRectangleModeEXT                        discardRectangleMode;
5720    uint32_t                                         discardRectangleCount;
5721    const VkRect2D*                                  pDiscardRectangles;
5722} VkPipelineDiscardRectangleStateCreateInfoEXT;
5723
5724
5725typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
5726
5727#ifndef VK_NO_PROTOTYPES
5728VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
5729    VkCommandBuffer                             commandBuffer,
5730    uint32_t                                    firstDiscardRectangle,
5731    uint32_t                                    discardRectangleCount,
5732    const VkRect2D*                             pDiscardRectangles);
5733#endif
5734
5735#define VK_EXT_swapchain_colorspace 1
5736#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 2
5737#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
5738
5739
5740#define VK_EXT_hdr_metadata 1
5741#define VK_EXT_HDR_METADATA_SPEC_VERSION  1
5742#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
5743
5744typedef struct VkXYColorEXT {
5745    float    x;
5746    float    y;
5747} VkXYColorEXT;
5748
5749typedef struct VkHdrMetadataEXT {
5750    VkStructureType    sType;
5751    const void*        pNext;
5752    VkXYColorEXT       displayPrimaryRed;
5753    VkXYColorEXT       displayPrimaryGreen;
5754    VkXYColorEXT       displayPrimaryBlue;
5755    VkXYColorEXT       whitePoint;
5756    float              maxLuminance;
5757    float              minLuminance;
5758    float              maxContentLightLevel;
5759    float              maxFrameAverageLightLevel;
5760} VkHdrMetadataEXT;
5761
5762
5763typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
5764
5765#ifndef VK_NO_PROTOTYPES
5766VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
5767    VkDevice                                    device,
5768    uint32_t                                    swapchainCount,
5769    const VkSwapchainKHR*                       pSwapchains,
5770    const VkHdrMetadataEXT*                     pMetadata);
5771#endif
5772
5773#define VK_KHR_shared_presentable_image 1
5774#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
5775#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
5776
5777typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
5778    VkStructureType      sType;
5779    void*                pNext;
5780    VkImageUsageFlags    sharedPresentSupportedUsageFlags;
5781} VkSharedPresentSurfaceCapabilitiesKHR;
5782
5783
5784typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
5785
5786#ifndef VK_NO_PROTOTYPES
5787VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
5788    VkDevice                                    device,
5789    VkSwapchainKHR                              swapchain);
5790#endif
5791
5792#define VK_KHR_get_surface_capabilities2 1
5793#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
5794#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
5795
5796typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
5797    VkStructureType    sType;
5798    const void*        pNext;
5799    VkSurfaceKHR       surface;
5800} VkPhysicalDeviceSurfaceInfo2KHR;
5801
5802typedef struct VkSurfaceCapabilities2KHR {
5803    VkStructureType             sType;
5804    void*                       pNext;
5805    VkSurfaceCapabilitiesKHR    surfaceCapabilities;
5806} VkSurfaceCapabilities2KHR;
5807
5808typedef struct VkSurfaceFormat2KHR {
5809    VkStructureType       sType;
5810    void*                 pNext;
5811    VkSurfaceFormatKHR    surfaceFormat;
5812} VkSurfaceFormat2KHR;
5813
5814
5815typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
5816typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
5817
5818#ifndef VK_NO_PROTOTYPES
5819VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
5820    VkPhysicalDevice                            physicalDevice,
5821    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
5822    VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
5823
5824VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
5825    VkPhysicalDevice                            physicalDevice,
5826    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
5827    uint32_t*                                   pSurfaceFormatCount,
5828    VkSurfaceFormat2KHR*                        pSurfaceFormats);
5829#endif
5830
5831
5832
5833#ifdef VK_USE_PLATFORM_IOS_MVK
5834#define VK_MVK_ios_surface 1
5835#define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
5836#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
5837
5838typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
5839
5840typedef struct VkIOSSurfaceCreateInfoMVK {
5841    VkStructureType               sType;
5842    const void*                   pNext;
5843    VkIOSSurfaceCreateFlagsMVK    flags;
5844    const void*                   pView;
5845} VkIOSSurfaceCreateInfoMVK;
5846
5847
5848typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
5849
5850#ifndef VK_NO_PROTOTYPES
5851VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
5852    VkInstance                                  instance,
5853    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
5854    const VkAllocationCallbacks*                pAllocator,
5855    VkSurfaceKHR*                               pSurface);
5856#endif
5857#endif /* VK_USE_PLATFORM_IOS_MVK */
5858
5859#ifdef VK_USE_PLATFORM_MACOS_MVK
5860#define VK_MVK_macos_surface 1
5861#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
5862#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
5863
5864typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
5865
5866typedef struct VkMacOSSurfaceCreateInfoMVK {
5867    VkStructureType                 sType;
5868    const void*                     pNext;
5869    VkMacOSSurfaceCreateFlagsMVK    flags;
5870    const void*                     pView;
5871} VkMacOSSurfaceCreateInfoMVK;
5872
5873
5874typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
5875
5876#ifndef VK_NO_PROTOTYPES
5877VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
5878    VkInstance                                  instance,
5879    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
5880    const VkAllocationCallbacks*                pAllocator,
5881    VkSurfaceKHR*                               pSurface);
5882#endif
5883#endif /* VK_USE_PLATFORM_MACOS_MVK */
5884
5885#ifdef __cplusplus
5886}
5887#endif
5888
5889#endif
5890