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