VirtualBox

source: vbox/trunk/src/VBox/Additions/3D/mesa/mesa-17.3.9/include/vulkan/vulkan.h@ 75443

Last change on this file since 75443 was 75443, checked in by vboxsync, 6 years ago

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette