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