projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
vk/vulkan.h: Add the VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT flag
[mesa.git] / include / vulkan / vulkan.h
1 #ifndef __vulkan_h_
2 #define __vulkan_h_ 1
3
4 #ifdef __cplusplus
5 extern "C" {
6 #endif
7
8 /*
9 ** Copyright (c) 2015 The Khronos Group Inc.
10 **
11 ** Permission is hereby granted, free of charge, to any person obtaining a
12 ** copy of this software and/or associated documentation files (the
13 ** "Materials"), to deal in the Materials without restriction, including
14 ** without limitation the rights to use, copy, modify, merge, publish,
15 ** distribute, sublicense, and/or sell copies of the Materials, and to
16 ** permit persons to whom the Materials are furnished to do so, subject to
17 ** the following conditions:
18 **
19 ** The above copyright notice and this permission notice shall be included
20 ** in all copies or substantial portions of the Materials.
21 **
22 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
26 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
27 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
29 */
30
31 /*
32 ** This header is generated from the Khronos Vulkan XML API Registry.
33 **
34 ** Generated on date 20150624
35 */
36
37
38 #define VK_VERSION_1_0 1
39 #include "vk_platform.h"
40
41 #define VK_MAKE_VERSION(major, minor, patch) \
42 ((major << 22) | (minor << 12) | patch)
43
44 // Vulkan API version supported by this file
45 #define VK_API_VERSION VK_MAKE_VERSION(0, 131, 0)
46
47 #if defined (__cplusplus) && (VK_UINTPTRLEAST64_MAX == UINTPTR_MAX)
48 #define VK_TYPE_SAFE_COMPATIBLE_HANDLES 1
49 #endif
50
51 #if defined(VK_TYPE_SAFE_COMPATIBLE_HANDLES) && !defined(VK_DISABLE_TYPE_SAFE_HANDLES)
52 #define VK_DEFINE_PTR_HANDLE(_obj) struct _obj##_T { char _dummy; }; typedef _obj##_T* _obj;
53 #define VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj;
54
55 #define VK_DEFINE_BASE_HANDLE(_obj) VK_DEFINE_PTR_HANDLE(_obj)
56 #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base)
57 #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base)
58 #else
59 #define VK_DEFINE_BASE_HANDLE(_obj) typedef VkUintPtrLeast64 _obj;
60 #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) typedef uintptr_t _obj;
61 #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) typedef VkUintPtrLeast64 _obj;
62 #endif
63
64
65 #define VK_MAX_PHYSICAL_DEVICE_NAME 256
66 #define VK_UUID_LENGTH 16
67 #define VK_MAX_EXTENSION_NAME 256
68 #define VK_MAX_MEMORY_TYPES 32
69 #define VK_MAX_MEMORY_HEAPS 16
70 #define VK_LOD_CLAMP_NONE MAX_FLOAT
71 #define VK_LAST_MIP_LEVEL UINT32_MAX
72 #define VK_LAST_ARRAY_SLICE UINT32_MAX
73 #define VK_WHOLE_SIZE UINT64_MAX
74 #define VK_ATTACHMENT_UNUSED UINT32_MAX
75 #define VK_TRUE 1
76 #define VK_FALSE 0
77 #define VK_NULL_HANDLE 0
78
79 VK_DEFINE_BASE_HANDLE(VkObject)
80 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkInstance, VkObject)
81 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkPhysicalDevice, VkObject)
82 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkDevice, VkObject)
83 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkQueue, VkObject)
84 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkCmdBuffer, VkObject)
85 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkNonDispatchable, VkObject)
86 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFence, VkNonDispatchable)
87 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDeviceMemory, VkNonDispatchable)
88 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBuffer, VkNonDispatchable)
89 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImage, VkNonDispatchable)
90 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSemaphore, VkNonDispatchable)
91 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkEvent, VkNonDispatchable)
92 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkQueryPool, VkNonDispatchable)
93 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBufferView, VkNonDispatchable)
94 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImageView, VkNonDispatchable)
95 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkAttachmentView, VkNonDispatchable)
96 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShaderModule, VkNonDispatchable)
97 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader, VkNonDispatchable)
98 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineCache, VkNonDispatchable)
99 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout, VkNonDispatchable)
100 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable)
101 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline, VkNonDispatchable)
102 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSetLayout, VkNonDispatchable)
103 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSampler, VkNonDispatchable)
104 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorPool, VkNonDispatchable)
105 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSet, VkNonDispatchable)
106 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicStateObject, VkNonDispatchable)
107 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicViewportState, VkDynamicStateObject)
108 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicRasterState, VkDynamicStateObject)
109 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicColorBlendState, VkDynamicStateObject)
110 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicDepthStencilState, VkDynamicStateObject)
111 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFramebuffer, VkNonDispatchable)
112
113
114 typedef enum {
115 VK_SUCCESS = 0,
116 VK_UNSUPPORTED = 1,
117 VK_NOT_READY = 2,
118 VK_TIMEOUT = 3,
119 VK_EVENT_SET = 4,
120 VK_EVENT_RESET = 5,
121 VK_ERROR_UNKNOWN = -1,
122 VK_ERROR_UNAVAILABLE = -2,
123 VK_ERROR_INITIALIZATION_FAILED = -3,
124 VK_ERROR_OUT_OF_HOST_MEMORY = -4,
125 VK_ERROR_OUT_OF_DEVICE_MEMORY = -5,
126 VK_ERROR_DEVICE_ALREADY_CREATED = -6,
127 VK_ERROR_DEVICE_LOST = -7,
128 VK_ERROR_INVALID_POINTER = -8,
129 VK_ERROR_INVALID_VALUE = -9,
130 VK_ERROR_INVALID_HANDLE = -10,
131 VK_ERROR_INVALID_ORDINAL = -11,
132 VK_ERROR_INVALID_MEMORY_SIZE = -12,
133 VK_ERROR_INVALID_EXTENSION = -13,
134 VK_ERROR_INVALID_FLAGS = -14,
135 VK_ERROR_INVALID_ALIGNMENT = -15,
136 VK_ERROR_INVALID_FORMAT = -16,
137 VK_ERROR_INVALID_IMAGE = -17,
138 VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -18,
139 VK_ERROR_INVALID_QUEUE_TYPE = -19,
140 VK_ERROR_INVALID_OBJECT_TYPE = -20,
141 VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -21,
142 VK_ERROR_BAD_SHADER_CODE = -22,
143 VK_ERROR_BAD_PIPELINE_DATA = -23,
144 VK_ERROR_NOT_MAPPABLE = -24,
145 VK_ERROR_MEMORY_MAP_FAILED = -25,
146 VK_ERROR_MEMORY_UNMAP_FAILED = -26,
147 VK_ERROR_INCOMPATIBLE_DEVICE = -27,
148 VK_ERROR_INCOMPATIBLE_DRIVER = -28,
149 VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -29,
150 VK_ERROR_BUILDING_COMMAND_BUFFER = -30,
151 VK_ERROR_MEMORY_NOT_BOUND = -31,
152 VK_ERROR_INCOMPATIBLE_QUEUE = -32,
153 VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_QUEUE,
154 VK_RESULT_END_RANGE = VK_EVENT_RESET,
155 VK_RESULT_NUM = (VK_EVENT_RESET - VK_ERROR_INCOMPATIBLE_QUEUE + 1),
156 VK_RESULT_MAX_ENUM = 0x7FFFFFFF
157 } VkResult;
158
159 typedef enum {
160 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
161 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
162 VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
163 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3,
164 VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO = 4,
165 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 5,
166 VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 6,
167 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 7,
168 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8,
169 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9,
170 VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 10,
171 VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 11,
172 VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 12,
173 VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 13,
174 VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14,
175 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15,
176 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16,
177 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17,
178 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18,
179 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19,
180 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20,
181 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21,
182 VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 22,
183 VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 23,
184 VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 24,
185 VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 25,
186 VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 26,
187 VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 27,
188 VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 28,
189 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29,
190 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30,
191 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31,
192 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32,
193 VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33,
194 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34,
195 VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 35,
196 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 36,
197 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 37,
198 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 38,
199 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 39,
200 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 40,
201 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 41,
202 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 42,
203 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 43,
204 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 44,
205 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 45,
206 VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 46,
207 VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 47,
208 VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 48,
209 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 49,
210 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
211 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
212 VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
213 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
214 } VkStructureType;
215
216 typedef enum {
217 VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0,
218 VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1,
219 VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2,
220 VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3,
221 VK_SYSTEM_ALLOC_TYPE_DEBUG = 4,
222 VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT,
223 VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG,
224 VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1),
225 VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
226 } VkSystemAllocType;
227
228 typedef enum {
229 VK_FORMAT_UNDEFINED = 0,
230 VK_FORMAT_R4G4_UNORM = 1,
231 VK_FORMAT_R4G4_USCALED = 2,
232 VK_FORMAT_R4G4B4A4_UNORM = 3,
233 VK_FORMAT_R4G4B4A4_USCALED = 4,
234 VK_FORMAT_R5G6B5_UNORM = 5,
235 VK_FORMAT_R5G6B5_USCALED = 6,
236 VK_FORMAT_R5G5B5A1_UNORM = 7,
237 VK_FORMAT_R5G5B5A1_USCALED = 8,
238 VK_FORMAT_R8_UNORM = 9,
239 VK_FORMAT_R8_SNORM = 10,
240 VK_FORMAT_R8_USCALED = 11,
241 VK_FORMAT_R8_SSCALED = 12,
242 VK_FORMAT_R8_UINT = 13,
243 VK_FORMAT_R8_SINT = 14,
244 VK_FORMAT_R8_SRGB = 15,
245 VK_FORMAT_R8G8_UNORM = 16,
246 VK_FORMAT_R8G8_SNORM = 17,
247 VK_FORMAT_R8G8_USCALED = 18,
248 VK_FORMAT_R8G8_SSCALED = 19,
249 VK_FORMAT_R8G8_UINT = 20,
250 VK_FORMAT_R8G8_SINT = 21,
251 VK_FORMAT_R8G8_SRGB = 22,
252 VK_FORMAT_R8G8B8_UNORM = 23,
253 VK_FORMAT_R8G8B8_SNORM = 24,
254 VK_FORMAT_R8G8B8_USCALED = 25,
255 VK_FORMAT_R8G8B8_SSCALED = 26,
256 VK_FORMAT_R8G8B8_UINT = 27,
257 VK_FORMAT_R8G8B8_SINT = 28,
258 VK_FORMAT_R8G8B8_SRGB = 29,
259 VK_FORMAT_R8G8B8A8_UNORM = 30,
260 VK_FORMAT_R8G8B8A8_SNORM = 31,
261 VK_FORMAT_R8G8B8A8_USCALED = 32,
262 VK_FORMAT_R8G8B8A8_SSCALED = 33,
263 VK_FORMAT_R8G8B8A8_UINT = 34,
264 VK_FORMAT_R8G8B8A8_SINT = 35,
265 VK_FORMAT_R8G8B8A8_SRGB = 36,
266 VK_FORMAT_R10G10B10A2_UNORM = 37,
267 VK_FORMAT_R10G10B10A2_SNORM = 38,
268 VK_FORMAT_R10G10B10A2_USCALED = 39,
269 VK_FORMAT_R10G10B10A2_SSCALED = 40,
270 VK_FORMAT_R10G10B10A2_UINT = 41,
271 VK_FORMAT_R10G10B10A2_SINT = 42,
272 VK_FORMAT_R16_UNORM = 43,
273 VK_FORMAT_R16_SNORM = 44,
274 VK_FORMAT_R16_USCALED = 45,
275 VK_FORMAT_R16_SSCALED = 46,
276 VK_FORMAT_R16_UINT = 47,
277 VK_FORMAT_R16_SINT = 48,
278 VK_FORMAT_R16_SFLOAT = 49,
279 VK_FORMAT_R16G16_UNORM = 50,
280 VK_FORMAT_R16G16_SNORM = 51,
281 VK_FORMAT_R16G16_USCALED = 52,
282 VK_FORMAT_R16G16_SSCALED = 53,
283 VK_FORMAT_R16G16_UINT = 54,
284 VK_FORMAT_R16G16_SINT = 55,
285 VK_FORMAT_R16G16_SFLOAT = 56,
286 VK_FORMAT_R16G16B16_UNORM = 57,
287 VK_FORMAT_R16G16B16_SNORM = 58,
288 VK_FORMAT_R16G16B16_USCALED = 59,
289 VK_FORMAT_R16G16B16_SSCALED = 60,
290 VK_FORMAT_R16G16B16_UINT = 61,
291 VK_FORMAT_R16G16B16_SINT = 62,
292 VK_FORMAT_R16G16B16_SFLOAT = 63,
293 VK_FORMAT_R16G16B16A16_UNORM = 64,
294 VK_FORMAT_R16G16B16A16_SNORM = 65,
295 VK_FORMAT_R16G16B16A16_USCALED = 66,
296 VK_FORMAT_R16G16B16A16_SSCALED = 67,
297 VK_FORMAT_R16G16B16A16_UINT = 68,
298 VK_FORMAT_R16G16B16A16_SINT = 69,
299 VK_FORMAT_R16G16B16A16_SFLOAT = 70,
300 VK_FORMAT_R32_UINT = 71,
301 VK_FORMAT_R32_SINT = 72,
302 VK_FORMAT_R32_SFLOAT = 73,
303 VK_FORMAT_R32G32_UINT = 74,
304 VK_FORMAT_R32G32_SINT = 75,
305 VK_FORMAT_R32G32_SFLOAT = 76,
306 VK_FORMAT_R32G32B32_UINT = 77,
307 VK_FORMAT_R32G32B32_SINT = 78,
308 VK_FORMAT_R32G32B32_SFLOAT = 79,
309 VK_FORMAT_R32G32B32A32_UINT = 80,
310 VK_FORMAT_R32G32B32A32_SINT = 81,
311 VK_FORMAT_R32G32B32A32_SFLOAT = 82,
312 VK_FORMAT_R64_SFLOAT = 83,
313 VK_FORMAT_R64G64_SFLOAT = 84,
314 VK_FORMAT_R64G64B64_SFLOAT = 85,
315 VK_FORMAT_R64G64B64A64_SFLOAT = 86,
316 VK_FORMAT_R11G11B10_UFLOAT = 87,
317 VK_FORMAT_R9G9B9E5_UFLOAT = 88,
318 VK_FORMAT_D16_UNORM = 89,
319 VK_FORMAT_D24_UNORM = 90,
320 VK_FORMAT_D32_SFLOAT = 91,
321 VK_FORMAT_S8_UINT = 92,
322 VK_FORMAT_D16_UNORM_S8_UINT = 93,
323 VK_FORMAT_D24_UNORM_S8_UINT = 94,
324 VK_FORMAT_D32_SFLOAT_S8_UINT = 95,
325 VK_FORMAT_BC1_RGB_UNORM = 96,
326 VK_FORMAT_BC1_RGB_SRGB = 97,
327 VK_FORMAT_BC1_RGBA_UNORM = 98,
328 VK_FORMAT_BC1_RGBA_SRGB = 99,
329 VK_FORMAT_BC2_UNORM = 100,
330 VK_FORMAT_BC2_SRGB = 101,
331 VK_FORMAT_BC3_UNORM = 102,
332 VK_FORMAT_BC3_SRGB = 103,
333 VK_FORMAT_BC4_UNORM = 104,
334 VK_FORMAT_BC4_SNORM = 105,
335 VK_FORMAT_BC5_UNORM = 106,
336 VK_FORMAT_BC5_SNORM = 107,
337 VK_FORMAT_BC6H_UFLOAT = 108,
338 VK_FORMAT_BC6H_SFLOAT = 109,
339 VK_FORMAT_BC7_UNORM = 110,
340 VK_FORMAT_BC7_SRGB = 111,
341 VK_FORMAT_ETC2_R8G8B8_UNORM = 112,
342 VK_FORMAT_ETC2_R8G8B8_SRGB = 113,
343 VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114,
344 VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115,
345 VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116,
346 VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117,
347 VK_FORMAT_EAC_R11_UNORM = 118,
348 VK_FORMAT_EAC_R11_SNORM = 119,
349 VK_FORMAT_EAC_R11G11_UNORM = 120,
350 VK_FORMAT_EAC_R11G11_SNORM = 121,
351 VK_FORMAT_ASTC_4x4_UNORM = 122,
352 VK_FORMAT_ASTC_4x4_SRGB = 123,
353 VK_FORMAT_ASTC_5x4_UNORM = 124,
354 VK_FORMAT_ASTC_5x4_SRGB = 125,
355 VK_FORMAT_ASTC_5x5_UNORM = 126,
356 VK_FORMAT_ASTC_5x5_SRGB = 127,
357 VK_FORMAT_ASTC_6x5_UNORM = 128,
358 VK_FORMAT_ASTC_6x5_SRGB = 129,
359 VK_FORMAT_ASTC_6x6_UNORM = 130,
360 VK_FORMAT_ASTC_6x6_SRGB = 131,
361 VK_FORMAT_ASTC_8x5_UNORM = 132,
362 VK_FORMAT_ASTC_8x5_SRGB = 133,
363 VK_FORMAT_ASTC_8x6_UNORM = 134,
364 VK_FORMAT_ASTC_8x6_SRGB = 135,
365 VK_FORMAT_ASTC_8x8_UNORM = 136,
366 VK_FORMAT_ASTC_8x8_SRGB = 137,
367 VK_FORMAT_ASTC_10x5_UNORM = 138,
368 VK_FORMAT_ASTC_10x5_SRGB = 139,
369 VK_FORMAT_ASTC_10x6_UNORM = 140,
370 VK_FORMAT_ASTC_10x6_SRGB = 141,
371 VK_FORMAT_ASTC_10x8_UNORM = 142,
372 VK_FORMAT_ASTC_10x8_SRGB = 143,
373 VK_FORMAT_ASTC_10x10_UNORM = 144,
374 VK_FORMAT_ASTC_10x10_SRGB = 145,
375 VK_FORMAT_ASTC_12x10_UNORM = 146,
376 VK_FORMAT_ASTC_12x10_SRGB = 147,
377 VK_FORMAT_ASTC_12x12_UNORM = 148,
378 VK_FORMAT_ASTC_12x12_SRGB = 149,
379 VK_FORMAT_B4G4R4A4_UNORM = 150,
380 VK_FORMAT_B5G5R5A1_UNORM = 151,
381 VK_FORMAT_B5G6R5_UNORM = 152,
382 VK_FORMAT_B5G6R5_USCALED = 153,
383 VK_FORMAT_B8G8R8_UNORM = 154,
384 VK_FORMAT_B8G8R8_SNORM = 155,
385 VK_FORMAT_B8G8R8_USCALED = 156,
386 VK_FORMAT_B8G8R8_SSCALED = 157,
387 VK_FORMAT_B8G8R8_UINT = 158,
388 VK_FORMAT_B8G8R8_SINT = 159,
389 VK_FORMAT_B8G8R8_SRGB = 160,
390 VK_FORMAT_B8G8R8A8_UNORM = 161,
391 VK_FORMAT_B8G8R8A8_SNORM = 162,
392 VK_FORMAT_B8G8R8A8_USCALED = 163,
393 VK_FORMAT_B8G8R8A8_SSCALED = 164,
394 VK_FORMAT_B8G8R8A8_UINT = 165,
395 VK_FORMAT_B8G8R8A8_SINT = 166,
396 VK_FORMAT_B8G8R8A8_SRGB = 167,
397 VK_FORMAT_B10G10R10A2_UNORM = 168,
398 VK_FORMAT_B10G10R10A2_SNORM = 169,
399 VK_FORMAT_B10G10R10A2_USCALED = 170,
400 VK_FORMAT_B10G10R10A2_SSCALED = 171,
401 VK_FORMAT_B10G10R10A2_UINT = 172,
402 VK_FORMAT_B10G10R10A2_SINT = 173,
403 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
404 VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT,
405 VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1),
406 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
407 } VkFormat;
408
409 typedef enum {
410 VK_IMAGE_TYPE_1D = 0,
411 VK_IMAGE_TYPE_2D = 1,
412 VK_IMAGE_TYPE_3D = 2,
413 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
414 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
415 VK_IMAGE_TYPE_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
416 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
417 } VkImageType;
418
419 typedef enum {
420 VK_IMAGE_TILING_LINEAR = 0,
421 VK_IMAGE_TILING_OPTIMAL = 1,
422 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR,
423 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL,
424 VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1),
425 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
426 } VkImageTiling;
427
428 typedef enum {
429 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
430 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
431 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
432 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
433 VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
434 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
435 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
436 VK_PHYSICAL_DEVICE_TYPE_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
437 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
438 } VkPhysicalDeviceType;
439
440 typedef enum {
441 VK_OBJECT_TYPE_INSTANCE = 0,
442 VK_OBJECT_TYPE_PHYSICAL_DEVICE = 1,
443 VK_OBJECT_TYPE_DEVICE = 2,
444 VK_OBJECT_TYPE_QUEUE = 3,
445 VK_OBJECT_TYPE_COMMAND_BUFFER = 4,
446 VK_OBJECT_TYPE_DEVICE_MEMORY = 5,
447 VK_OBJECT_TYPE_BUFFER = 6,
448 VK_OBJECT_TYPE_BUFFER_VIEW = 7,
449 VK_OBJECT_TYPE_IMAGE = 8,
450 VK_OBJECT_TYPE_IMAGE_VIEW = 9,
451 VK_OBJECT_TYPE_ATTACHMENT_VIEW = 10,
452 VK_OBJECT_TYPE_SHADER_MODULE = 11,
453 VK_OBJECT_TYPE_SHADER = 12,
454 VK_OBJECT_TYPE_PIPELINE = 13,
455 VK_OBJECT_TYPE_PIPELINE_LAYOUT = 14,
456 VK_OBJECT_TYPE_SAMPLER = 15,
457 VK_OBJECT_TYPE_DESCRIPTOR_SET = 16,
458 VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 17,
459 VK_OBJECT_TYPE_DESCRIPTOR_POOL = 18,
460 VK_OBJECT_TYPE_DYNAMIC_VP_STATE = 19,
461 VK_OBJECT_TYPE_DYNAMIC_RS_STATE = 20,
462 VK_OBJECT_TYPE_DYNAMIC_CB_STATE = 21,
463 VK_OBJECT_TYPE_DYNAMIC_DS_STATE = 22,
464 VK_OBJECT_TYPE_FENCE = 23,
465 VK_OBJECT_TYPE_SEMAPHORE = 24,
466 VK_OBJECT_TYPE_EVENT = 25,
467 VK_OBJECT_TYPE_QUERY_POOL = 26,
468 VK_OBJECT_TYPE_FRAMEBUFFER = 27,
469 VK_OBJECT_TYPE_RENDER_PASS = 28,
470 VK_OBJECT_TYPE_PIPELINE_CACHE = 29,
471 VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE,
472 VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_PIPELINE_CACHE,
473 VK_OBJECT_TYPE_NUM = (VK_OBJECT_TYPE_PIPELINE_CACHE - VK_OBJECT_TYPE_INSTANCE + 1),
474 VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
475 } VkObjectType;
476
477 typedef enum {
478 VK_IMAGE_ASPECT_COLOR = 0,
479 VK_IMAGE_ASPECT_DEPTH = 1,
480 VK_IMAGE_ASPECT_STENCIL = 2,
481 VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR,
482 VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_STENCIL,
483 VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_STENCIL - VK_IMAGE_ASPECT_COLOR + 1),
484 VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF
485 } VkImageAspect;
486
487 typedef enum {
488 VK_QUERY_TYPE_OCCLUSION = 0,
489 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
490 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
491 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS,
492 VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1),
493 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
494 } VkQueryType;
495
496 typedef enum {
497 VK_BUFFER_VIEW_TYPE_RAW = 0,
498 VK_BUFFER_VIEW_TYPE_FORMATTED = 1,
499 VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_TYPE_RAW,
500 VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPE_FORMATTED,
501 VK_BUFFER_VIEW_TYPE_NUM = (VK_BUFFER_VIEW_TYPE_FORMATTED - VK_BUFFER_VIEW_TYPE_RAW + 1),
502 VK_BUFFER_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
503 } VkBufferViewType;
504
505 typedef enum {
506 VK_IMAGE_VIEW_TYPE_1D = 0,
507 VK_IMAGE_VIEW_TYPE_2D = 1,
508 VK_IMAGE_VIEW_TYPE_3D = 2,
509 VK_IMAGE_VIEW_TYPE_CUBE = 3,
510 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
511 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
512 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
513 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
514 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
515 VK_IMAGE_VIEW_TYPE_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
516 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
517 } VkImageViewType;
518
519 typedef enum {
520 VK_CHANNEL_SWIZZLE_ZERO = 0,
521 VK_CHANNEL_SWIZZLE_ONE = 1,
522 VK_CHANNEL_SWIZZLE_R = 2,
523 VK_CHANNEL_SWIZZLE_G = 3,
524 VK_CHANNEL_SWIZZLE_B = 4,
525 VK_CHANNEL_SWIZZLE_A = 5,
526 VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO,
527 VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A,
528 VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1),
529 VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
530 } VkChannelSwizzle;
531
532 typedef enum {
533 VK_SHADER_STAGE_VERTEX = 0,
534 VK_SHADER_STAGE_TESS_CONTROL = 1,
535 VK_SHADER_STAGE_TESS_EVALUATION = 2,
536 VK_SHADER_STAGE_GEOMETRY = 3,
537 VK_SHADER_STAGE_FRAGMENT = 4,
538 VK_SHADER_STAGE_COMPUTE = 5,
539 VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX,
540 VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE,
541 VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1),
542 VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF
543 } VkShaderStage;
544
545 typedef enum {
546 VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0,
547 VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1,
548 VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX,
549 VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE,
550 VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1),
551 VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF
552 } VkVertexInputStepRate;
553
554 typedef enum {
555 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
556 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
557 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
558 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
559 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
560 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
561 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 6,
562 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7,
563 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8,
564 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9,
565 VK_PRIMITIVE_TOPOLOGY_PATCH = 10,
566 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
567 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH,
568 VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
569 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
570 } VkPrimitiveTopology;
571
572 typedef enum {
573 VK_FILL_MODE_POINTS = 0,
574 VK_FILL_MODE_WIREFRAME = 1,
575 VK_FILL_MODE_SOLID = 2,
576 VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS,
577 VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID,
578 VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1),
579 VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF
580 } VkFillMode;
581
582 typedef enum {
583 VK_CULL_MODE_NONE = 0,
584 VK_CULL_MODE_FRONT = 1,
585 VK_CULL_MODE_BACK = 2,
586 VK_CULL_MODE_FRONT_AND_BACK = 3,
587 VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE,
588 VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK,
589 VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1),
590 VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF
591 } VkCullMode;
592
593 typedef enum {
594 VK_FRONT_FACE_CCW = 0,
595 VK_FRONT_FACE_CW = 1,
596 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW,
597 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW,
598 VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1),
599 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
600 } VkFrontFace;
601
602 typedef enum {
603 VK_COMPARE_OP_NEVER = 0,
604 VK_COMPARE_OP_LESS = 1,
605 VK_COMPARE_OP_EQUAL = 2,
606 VK_COMPARE_OP_LESS_EQUAL = 3,
607 VK_COMPARE_OP_GREATER = 4,
608 VK_COMPARE_OP_NOT_EQUAL = 5,
609 VK_COMPARE_OP_GREATER_EQUAL = 6,
610 VK_COMPARE_OP_ALWAYS = 7,
611 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
612 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
613 VK_COMPARE_OP_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
614 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
615 } VkCompareOp;
616
617 typedef enum {
618 VK_STENCIL_OP_KEEP = 0,
619 VK_STENCIL_OP_ZERO = 1,
620 VK_STENCIL_OP_REPLACE = 2,
621 VK_STENCIL_OP_INC_CLAMP = 3,
622 VK_STENCIL_OP_DEC_CLAMP = 4,
623 VK_STENCIL_OP_INVERT = 5,
624 VK_STENCIL_OP_INC_WRAP = 6,
625 VK_STENCIL_OP_DEC_WRAP = 7,
626 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
627 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP,
628 VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1),
629 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
630 } VkStencilOp;
631
632 typedef enum {
633 VK_LOGIC_OP_CLEAR = 0,
634 VK_LOGIC_OP_AND = 1,
635 VK_LOGIC_OP_AND_REVERSE = 2,
636 VK_LOGIC_OP_COPY = 3,
637 VK_LOGIC_OP_AND_INVERTED = 4,
638 VK_LOGIC_OP_NOOP = 5,
639 VK_LOGIC_OP_XOR = 6,
640 VK_LOGIC_OP_OR = 7,
641 VK_LOGIC_OP_NOR = 8,
642 VK_LOGIC_OP_EQUIV = 9,
643 VK_LOGIC_OP_INVERT = 10,
644 VK_LOGIC_OP_OR_REVERSE = 11,
645 VK_LOGIC_OP_COPY_INVERTED = 12,
646 VK_LOGIC_OP_OR_INVERTED = 13,
647 VK_LOGIC_OP_NAND = 14,
648 VK_LOGIC_OP_SET = 15,
649 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
650 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
651 VK_LOGIC_OP_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
652 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
653 } VkLogicOp;
654
655 typedef enum {
656 VK_BLEND_ZERO = 0,
657 VK_BLEND_ONE = 1,
658 VK_BLEND_SRC_COLOR = 2,
659 VK_BLEND_ONE_MINUS_SRC_COLOR = 3,
660 VK_BLEND_DEST_COLOR = 4,
661 VK_BLEND_ONE_MINUS_DEST_COLOR = 5,
662 VK_BLEND_SRC_ALPHA = 6,
663 VK_BLEND_ONE_MINUS_SRC_ALPHA = 7,
664 VK_BLEND_DEST_ALPHA = 8,
665 VK_BLEND_ONE_MINUS_DEST_ALPHA = 9,
666 VK_BLEND_CONSTANT_COLOR = 10,
667 VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11,
668 VK_BLEND_CONSTANT_ALPHA = 12,
669 VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13,
670 VK_BLEND_SRC_ALPHA_SATURATE = 14,
671 VK_BLEND_SRC1_COLOR = 15,
672 VK_BLEND_ONE_MINUS_SRC1_COLOR = 16,
673 VK_BLEND_SRC1_ALPHA = 17,
674 VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18,
675 VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO,
676 VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA,
677 VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1),
678 VK_BLEND_MAX_ENUM = 0x7FFFFFFF
679 } VkBlend;
680
681 typedef enum {
682 VK_BLEND_OP_ADD = 0,
683 VK_BLEND_OP_SUBTRACT = 1,
684 VK_BLEND_OP_REVERSE_SUBTRACT = 2,
685 VK_BLEND_OP_MIN = 3,
686 VK_BLEND_OP_MAX = 4,
687 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
688 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
689 VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
690 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
691 } VkBlendOp;
692
693 typedef enum {
694 VK_TEX_FILTER_NEAREST = 0,
695 VK_TEX_FILTER_LINEAR = 1,
696 VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST,
697 VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR,
698 VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1),
699 VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF
700 } VkTexFilter;
701
702 typedef enum {
703 VK_TEX_MIPMAP_MODE_BASE = 0,
704 VK_TEX_MIPMAP_MODE_NEAREST = 1,
705 VK_TEX_MIPMAP_MODE_LINEAR = 2,
706 VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE,
707 VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR,
708 VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1),
709 VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
710 } VkTexMipmapMode;
711
712 typedef enum {
713 VK_TEX_ADDRESS_WRAP = 0,
714 VK_TEX_ADDRESS_MIRROR = 1,
715 VK_TEX_ADDRESS_CLAMP = 2,
716 VK_TEX_ADDRESS_MIRROR_ONCE = 3,
717 VK_TEX_ADDRESS_CLAMP_BORDER = 4,
718 VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP,
719 VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER,
720 VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_CLAMP_BORDER - VK_TEX_ADDRESS_WRAP + 1),
721 VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF
722 } VkTexAddress;
723
724 typedef enum {
725 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
726 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
727 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
728 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
729 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
730 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
731 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
732 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
733 VK_BORDER_COLOR_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
734 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
735 } VkBorderColor;
736
737 typedef enum {
738 VK_DESCRIPTOR_TYPE_SAMPLER = 0,
739 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
740 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
741 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
742 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
743 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
744 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
745 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
746 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
747 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
748 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
749 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
750 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
751 VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
752 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
753 } VkDescriptorType;
754
755 typedef enum {
756 VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0,
757 VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1,
758 VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
759 VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC,
760 VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1),
761 VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF
762 } VkDescriptorPoolUsage;
763
764 typedef enum {
765 VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0,
766 VK_DESCRIPTOR_SET_USAGE_STATIC = 1,
767 VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT,
768 VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC,
769 VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1),
770 VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF
771 } VkDescriptorSetUsage;
772
773 typedef enum {
774 VK_IMAGE_LAYOUT_UNDEFINED = 0,
775 VK_IMAGE_LAYOUT_GENERAL = 1,
776 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
777 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
778 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
779 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
780 VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6,
781 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7,
782 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
783 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
784 VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL - VK_IMAGE_LAYOUT_UNDEFINED + 1),
785 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
786 } VkImageLayout;
787
788 typedef enum {
789 VK_ATTACHMENT_LOAD_OP_LOAD = 0,
790 VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
791 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
792 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
793 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
794 VK_ATTACHMENT_LOAD_OP_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
795 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
796 } VkAttachmentLoadOp;
797
798 typedef enum {
799 VK_ATTACHMENT_STORE_OP_STORE = 0,
800 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
801 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
802 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
803 VK_ATTACHMENT_STORE_OP_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
804 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
805 } VkAttachmentStoreOp;
806
807 typedef enum {
808 VK_PIPELINE_BIND_POINT_COMPUTE = 0,
809 VK_PIPELINE_BIND_POINT_GRAPHICS = 1,
810 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
811 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
812 VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1),
813 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
814 } VkPipelineBindPoint;
815
816 typedef enum {
817 VK_CMD_BUFFER_LEVEL_PRIMARY = 0,
818 VK_CMD_BUFFER_LEVEL_SECONDARY = 1,
819 VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY,
820 VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY,
821 VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1),
822 VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
823 } VkCmdBufferLevel;
824
825 typedef enum {
826 VK_INDEX_TYPE_UINT16 = 0,
827 VK_INDEX_TYPE_UINT32 = 1,
828 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
829 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
830 VK_INDEX_TYPE_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
831 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
832 } VkIndexType;
833
834 typedef enum {
835 VK_TIMESTAMP_TYPE_TOP = 0,
836 VK_TIMESTAMP_TYPE_BOTTOM = 1,
837 VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP,
838 VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM,
839 VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 1),
840 VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF
841 } VkTimestampType;
842
843 typedef enum {
844 VK_RENDER_PASS_CONTENTS_INLINE = 0,
845 VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1,
846 VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE,
847 VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS,
848 VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1),
849 VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
850 } VkRenderPassContents;
851
852
853 typedef enum {
854 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
855 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
856 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
857 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
858 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
859 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
860 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
861 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
862 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
863 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
864 VK_FORMAT_FEATURE_CONVERSION_BIT = 0x00000400,
865 } VkFormatFeatureFlagBits;
866 typedef VkFlags VkFormatFeatureFlags;
867
868 typedef enum {
869 VK_IMAGE_USAGE_GENERAL = 0,
870 VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
871 VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
872 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
873 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
874 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
875 VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020,
876 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
877 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
878 } VkImageUsageFlagBits;
879 typedef VkFlags VkImageUsageFlags;
880
881 typedef enum {
882 VK_QUEUE_GRAPHICS_BIT = 0x00000001,
883 VK_QUEUE_COMPUTE_BIT = 0x00000002,
884 VK_QUEUE_DMA_BIT = 0x00000004,
885 VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008,
886 VK_QUEUE_EXTENDED_BIT = 0x40000000,
887 } VkQueueFlagBits;
888 typedef VkFlags VkQueueFlags;
889
890 typedef enum {
891 VK_MEMORY_PROPERTY_DEVICE_ONLY = 0,
892 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001,
893 VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002,
894 VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004,
895 VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008,
896 } VkMemoryPropertyFlagBits;
897 typedef VkFlags VkMemoryPropertyFlags;
898
899 typedef enum {
900 VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001,
901 } VkMemoryHeapFlagBits;
902 typedef VkFlags VkMemoryHeapFlags;
903
904 typedef enum {
905 VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
906 } VkDeviceCreateFlagBits;
907 typedef VkFlags VkDeviceCreateFlags;
908 typedef VkFlags VkMemoryMapFlags;
909
910 typedef enum {
911 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
912 } VkFenceCreateFlagBits;
913 typedef VkFlags VkFenceCreateFlags;
914 typedef VkFlags VkSemaphoreCreateFlags;
915 typedef VkFlags VkEventCreateFlags;
916
917 typedef enum {
918 VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001,
919 VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002,
920 VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004,
921 VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008,
922 VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010,
923 VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020,
924 VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040,
925 VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080,
926 VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100,
927 VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200,
928 VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400,
929 } VkQueryPipelineStatisticFlagBits;
930 typedef VkFlags VkQueryPipelineStatisticFlags;
931
932 typedef enum {
933 VK_QUERY_RESULT_DEFAULT = 0,
934 VK_QUERY_RESULT_64_BIT = 0x00000001,
935 VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
936 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
937 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
938 } VkQueryResultFlagBits;
939 typedef VkFlags VkQueryResultFlags;
940
941 typedef enum {
942 VK_BUFFER_USAGE_GENERAL = 0,
943 VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
944 VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
945 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
946 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
947 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
948 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
949 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
950 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
951 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
952 } VkBufferUsageFlagBits;
953 typedef VkFlags VkBufferUsageFlags;
954
955 typedef enum {
956 VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001,
957 } VkBufferCreateFlagBits;
958 typedef VkFlags VkBufferCreateFlags;
959
960 typedef enum {
961 VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001,
962 VK_IMAGE_CREATE_SPARSE_BIT = 0x00000002,
963 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000004,
964 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000008,
965 } VkImageCreateFlagBits;
966 typedef VkFlags VkImageCreateFlags;
967
968 typedef enum {
969 VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
970 VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
971 } VkAttachmentViewCreateFlagBits;
972 typedef VkFlags VkAttachmentViewCreateFlags;
973 typedef VkFlags VkShaderModuleCreateFlags;
974 typedef VkFlags VkShaderCreateFlags;
975
976 typedef enum {
977 VK_CHANNEL_R_BIT = 0x00000001,
978 VK_CHANNEL_G_BIT = 0x00000002,
979 VK_CHANNEL_B_BIT = 0x00000004,
980 VK_CHANNEL_A_BIT = 0x00000008,
981 } VkChannelFlagBits;
982 typedef VkFlags VkChannelFlags;
983
984 typedef enum {
985 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
986 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
987 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
988 } VkPipelineCreateFlagBits;
989 typedef VkFlags VkPipelineCreateFlags;
990
991 typedef enum {
992 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
993 VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002,
994 VK_SHADER_STAGE_TESS_EVALUATION_BIT = 0x00000004,
995 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
996 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
997 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
998 VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
999 } VkShaderStageFlagBits;
1000 typedef VkFlags VkShaderStageFlags;
1001
1002 typedef enum {
1003 VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001,
1004 } VkSubpassDescriptionFlagBits;
1005 typedef VkFlags VkSubpassDescriptionFlags;
1006
1007 typedef enum {
1008 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
1009 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
1010 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
1011 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
1012 VK_PIPELINE_STAGE_TESS_CONTROL_SHADER_BIT = 0x00000010,
1013 VK_PIPELINE_STAGE_TESS_EVALUATION_SHADER_BIT = 0x00000020,
1014 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
1015 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
1016 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
1017 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
1018 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
1019 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
1020 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
1021 VK_PIPELINE_STAGE_TRANSITION_BIT = 0x00002000,
1022 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
1023 VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF,
1024 VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00003FFF,
1025 } VkPipelineStageFlagBits;
1026 typedef VkFlags VkPipelineStageFlags;
1027
1028 typedef enum {
1029 VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001,
1030 VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002,
1031 VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004,
1032 VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008,
1033 VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010,
1034 } VkMemoryOutputFlagBits;
1035 typedef VkFlags VkMemoryOutputFlags;
1036
1037 typedef enum {
1038 VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001,
1039 VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002,
1040 VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004,
1041 VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008,
1042 VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010,
1043 VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020,
1044 VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040,
1045 VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080,
1046 VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100,
1047 VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200,
1048 } VkMemoryInputFlagBits;
1049 typedef VkFlags VkMemoryInputFlags;
1050 typedef VkFlags VkCmdBufferCreateFlags;
1051
1052 typedef enum {
1053 VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001,
1054 VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
1055 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
1056 VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
1057 VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010,
1058 } VkCmdBufferOptimizeFlagBits;
1059 typedef VkFlags VkCmdBufferOptimizeFlags;
1060
1061 typedef enum {
1062 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
1063 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
1064 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
1065 } VkImageAspectFlagBits;
1066 typedef VkFlags VkImageAspectFlags;
1067
1068 typedef enum {
1069 VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001,
1070 } VkQueryControlFlagBits;
1071 typedef VkFlags VkQueryControlFlags;
1072
1073 typedef struct {
1074 VkStructureType sType;
1075 const void* pNext;
1076 const char* pAppName;
1077 uint32_t appVersion;
1078 const char* pEngineName;
1079 uint32_t engineVersion;
1080 uint32_t apiVersion;
1081 } VkApplicationInfo;
1082
1083 typedef void* (VKAPI *PFN_vkAllocFunction)(
1084 void* pUserData,
1085 size_t size,
1086 size_t alignment,
1087 VkSystemAllocType allocType);
1088
1089 typedef void (VKAPI *PFN_vkFreeFunction)(
1090 void* pUserData,
1091 void* pMem);
1092
1093 typedef struct {
1094 void* pUserData;
1095 PFN_vkAllocFunction pfnAlloc;
1096 PFN_vkFreeFunction pfnFree;
1097 } VkAllocCallbacks;
1098
1099 typedef struct {
1100 VkStructureType sType;
1101 const void* pNext;
1102 const VkApplicationInfo* pAppInfo;
1103 const VkAllocCallbacks* pAllocCb;
1104 uint32_t extensionCount;
1105 const char*const* ppEnabledExtensionNames;
1106 } VkInstanceCreateInfo;
1107
1108 typedef struct {
1109 VkBool32 robustBufferAccess;
1110 VkBool32 fullDrawIndexUint32;
1111 VkBool32 imageCubeArray;
1112 VkBool32 independentBlend;
1113 VkBool32 geometryShader;
1114 VkBool32 tessellationShader;
1115 VkBool32 sampleRateShading;
1116 VkBool32 dualSourceBlend;
1117 VkBool32 logicOp;
1118 VkBool32 instancedDrawIndirect;
1119 VkBool32 depthClip;
1120 VkBool32 depthBiasClamp;
1121 VkBool32 fillModeNonSolid;
1122 VkBool32 depthBounds;
1123 VkBool32 wideLines;
1124 VkBool32 largePoints;
1125 VkBool32 textureCompressionETC2;
1126 VkBool32 textureCompressionASTC_LDR;
1127 VkBool32 textureCompressionBC;
1128 VkBool32 pipelineStatisticsQuery;
1129 VkBool32 vertexSideEffects;
1130 VkBool32 tessellationSideEffects;
1131 VkBool32 geometrySideEffects;
1132 VkBool32 fragmentSideEffects;
1133 VkBool32 shaderTessellationPointSize;
1134 VkBool32 shaderGeometryPointSize;
1135 VkBool32 shaderTextureGatherExtended;
1136 VkBool32 shaderStorageImageExtendedFormats;
1137 VkBool32 shaderStorageImageMultisample;
1138 VkBool32 shaderStorageBufferArrayConstantIndexing;
1139 VkBool32 shaderStorageImageArrayConstantIndexing;
1140 VkBool32 shaderUniformBufferArrayDynamicIndexing;
1141 VkBool32 shaderSampledImageArrayDynamicIndexing;
1142 VkBool32 shaderStorageBufferArrayDynamicIndexing;
1143 VkBool32 shaderStorageImageArrayDynamicIndexing;
1144 VkBool32 shaderClipDistance;
1145 VkBool32 shaderCullDistance;
1146 VkBool32 shaderFloat64;
1147 VkBool32 shaderInt64;
1148 VkBool32 shaderFloat16;
1149 VkBool32 shaderInt16;
1150 } VkPhysicalDeviceFeatures;
1151
1152 typedef struct {
1153 VkFormatFeatureFlags linearTilingFeatures;
1154 VkFormatFeatureFlags optimalTilingFeatures;
1155 } VkFormatProperties;
1156
1157 typedef struct {
1158 uint32_t maxImageDimension1D;
1159 uint32_t maxImageDimension2D;
1160 uint32_t maxImageDimension3D;
1161 uint32_t maxImageDimensionCube;
1162 uint32_t maxImageArrayLayers;
1163 uint32_t maxTexelBufferSize;
1164 uint32_t maxUniformBufferSize;
1165 uint32_t maxStorageBufferSize;
1166 uint32_t maxPushConstantsSize;
1167 uint32_t maxMemoryAllocationCount;
1168 uint32_t maxBoundDescriptorSets;
1169 uint32_t maxDescriptorSets;
1170 uint32_t maxPerStageDescriptorSamplers;
1171 uint32_t maxPerStageDescriptorUniformBuffers;
1172 uint32_t maxPerStageDescriptorStorageBuffers;
1173 uint32_t maxPerStageDescriptorSampledImages;
1174 uint32_t maxPerStageDescriptorStorageImages;
1175 uint32_t maxDescriptorSetSamplers;
1176 uint32_t maxDescriptorSetUniformBuffers;
1177 uint32_t maxDescriptorSetStorageBuffers;
1178 uint32_t maxDescriptorSetSampledImages;
1179 uint32_t maxDescriptorSetStorageImages;
1180 uint32_t maxVertexInputAttributes;
1181 uint32_t maxVertexInputAttributeOffset;
1182 uint32_t maxVertexInputBindingStride;
1183 uint32_t maxVertexOutputComponents;
1184 uint32_t maxTessGenLevel;
1185 uint32_t maxTessPatchSize;
1186 uint32_t maxTessControlPerVertexInputComponents;
1187 uint32_t maxTessControlPerVertexOutputComponents;
1188 uint32_t maxTessControlPerPatchOutputComponents;
1189 uint32_t maxTessControlTotalOutputComponents;
1190 uint32_t maxTessEvaluationInputComponents;
1191 uint32_t maxTessEvaluationOutputComponents;
1192 uint32_t maxGeometryShaderInvocations;
1193 uint32_t maxGeometryInputComponents;
1194 uint32_t maxGeometryOutputComponents;
1195 uint32_t maxGeometryOutputVertices;
1196 uint32_t maxGeometryTotalOutputComponents;
1197 uint32_t maxFragmentInputComponents;
1198 uint32_t maxFragmentOutputBuffers;
1199 uint32_t maxFragmentDualSourceBuffers;
1200 uint32_t maxFragmentCombinedOutputResources;
1201 uint32_t maxComputeSharedMemorySize;
1202 uint32_t maxComputeWorkGroupCount[3];
1203 uint32_t maxComputeWorkGroupInvocations;
1204 uint32_t maxComputeWorkGroupSize[3];
1205 uint32_t subPixelPrecisionBits;
1206 uint32_t subTexelPrecisionBits;
1207 uint32_t mipmapPrecisionBits;
1208 uint32_t maxDrawIndexedIndexValue;
1209 uint32_t maxDrawIndirectInstanceCount;
1210 VkBool32 primitiveRestartForPatches;
1211 float maxSamplerLodBias;
1212 uint32_t maxSamplerAnisotropy;
1213 uint32_t maxViewports;
1214 uint32_t maxDynamicViewportStates;
1215 uint32_t maxViewportDimensions[2];
1216 float viewportBoundsRange[2];
1217 uint32_t viewportSubPixelBits;
1218 uint32_t minMemoryMapAlignment;
1219 uint32_t minTexelBufferOffsetAlignment;
1220 uint32_t minUniformBufferOffsetAlignment;
1221 uint32_t minStorageBufferOffsetAlignment;
1222 uint32_t minTexelOffset;
1223 uint32_t maxTexelOffset;
1224 uint32_t minTexelGatherOffset;
1225 uint32_t maxTexelGatherOffset;
1226 float minInterpolationOffset;
1227 float maxInterpolationOffset;
1228 uint32_t subPixelInterpolationOffsetBits;
1229 uint32_t maxFramebufferWidth;
1230 uint32_t maxFramebufferHeight;
1231 uint32_t maxFramebufferLayers;
1232 uint32_t maxFramebufferColorSamples;
1233 uint32_t maxFramebufferDepthSamples;
1234 uint32_t maxFramebufferStencilSamples;
1235 uint32_t maxColorAttachments;
1236 uint32_t maxSampledImageColorSamples;
1237 uint32_t maxSampledImageDepthSamples;
1238 uint32_t maxSampledImageIntegerSamples;
1239 uint32_t maxStorageImageSamples;
1240 uint32_t maxSampleMaskWords;
1241 uint64_t timestampFrequency;
1242 uint32_t maxClipDistances;
1243 uint32_t maxCullDistances;
1244 uint32_t maxCombinedClipAndCullDistances;
1245 float pointSizeRange[2];
1246 float lineWidthRange[2];
1247 float pointSizeGranularity;
1248 float lineWidthGranularity;
1249 } VkPhysicalDeviceLimits;
1250
1251 typedef struct {
1252 uint32_t apiVersion;
1253 uint32_t driverVersion;
1254 uint32_t vendorId;
1255 uint32_t deviceId;
1256 VkPhysicalDeviceType deviceType;
1257 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
1258 uint8_t pipelineCacheUUID[VK_UUID_LENGTH];
1259 } VkPhysicalDeviceProperties;
1260
1261 typedef struct {
1262 VkQueueFlags queueFlags;
1263 uint32_t queueCount;
1264 VkBool32 supportsTimestamps;
1265 } VkPhysicalDeviceQueueProperties;
1266
1267 typedef struct {
1268 VkMemoryPropertyFlags propertyFlags;
1269 uint32_t heapIndex;
1270 } VkMemoryType;
1271
1272 typedef struct {
1273 VkDeviceSize size;
1274 VkMemoryHeapFlags flags;
1275 } VkMemoryHeap;
1276
1277 typedef struct {
1278 uint32_t memoryTypeCount;
1279 VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
1280 uint32_t memoryHeapCount;
1281 VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
1282 } VkPhysicalDeviceMemoryProperties;
1283
1284 typedef void (VKAPI *PFN_vkVoidFunction)(void);
1285 typedef struct {
1286 uint32_t queueNodeIndex;
1287 uint32_t queueCount;
1288 } VkDeviceQueueCreateInfo;
1289
1290 typedef struct {
1291 VkStructureType sType;
1292 const void* pNext;
1293 uint32_t queueRecordCount;
1294 const VkDeviceQueueCreateInfo* pRequestedQueues;
1295 uint32_t extensionCount;
1296 const char*const* ppEnabledExtensionNames;
1297 const VkPhysicalDeviceFeatures* pEnabledFeatures;
1298 VkDeviceCreateFlags flags;
1299 } VkDeviceCreateInfo;
1300
1301 typedef struct {
1302 char extName[VK_MAX_EXTENSION_NAME];
1303 uint32_t version;
1304 } VkExtensionProperties;
1305
1306 typedef struct {
1307 VkStructureType sType;
1308 const void* pNext;
1309 VkDeviceSize allocationSize;
1310 uint32_t memoryTypeIndex;
1311 } VkMemoryAllocInfo;
1312
1313 typedef struct {
1314 VkStructureType sType;
1315 const void* pNext;
1316 VkDeviceMemory mem;
1317 VkDeviceSize offset;
1318 VkDeviceSize size;
1319 } VkMappedMemoryRange;
1320
1321 typedef struct {
1322 VkDeviceSize size;
1323 VkDeviceSize alignment;
1324 VkDeviceSize granularity;
1325 uint32_t memoryTypeBits;
1326 } VkMemoryRequirements;
1327
1328 typedef struct {
1329 VkImageAspect aspect;
1330 uint32_t mipLevel;
1331 uint32_t arraySlice;
1332 } VkImageSubresource;
1333
1334 typedef struct {
1335 int32_t x;
1336 int32_t y;
1337 int32_t z;
1338 } VkOffset3D;
1339
1340 typedef struct {
1341 int32_t width;
1342 int32_t height;
1343 int32_t depth;
1344 } VkExtent3D;
1345
1346 typedef struct {
1347 VkImageSubresource subresource;
1348 VkOffset3D offset;
1349 VkExtent3D extent;
1350 } VkImageMemoryBindInfo;
1351
1352 typedef struct {
1353 VkStructureType sType;
1354 const void* pNext;
1355 VkFenceCreateFlags flags;
1356 } VkFenceCreateInfo;
1357
1358 typedef struct {
1359 VkStructureType sType;
1360 const void* pNext;
1361 VkSemaphoreCreateFlags flags;
1362 } VkSemaphoreCreateInfo;
1363
1364 typedef struct {
1365 VkStructureType sType;
1366 const void* pNext;
1367 VkEventCreateFlags flags;
1368 } VkEventCreateInfo;
1369
1370 typedef struct {
1371 VkStructureType sType;
1372 const void* pNext;
1373 VkQueryType queryType;
1374 uint32_t slots;
1375 VkQueryPipelineStatisticFlags pipelineStatistics;
1376 } VkQueryPoolCreateInfo;
1377
1378 typedef struct {
1379 VkStructureType sType;
1380 const void* pNext;
1381 VkDeviceSize size;
1382 VkBufferUsageFlags usage;
1383 VkBufferCreateFlags flags;
1384 } VkBufferCreateInfo;
1385
1386 typedef struct {
1387 VkStructureType sType;
1388 const void* pNext;
1389 VkBuffer buffer;
1390 VkBufferViewType viewType;
1391 VkFormat format;
1392 VkDeviceSize offset;
1393 VkDeviceSize range;
1394 } VkBufferViewCreateInfo;
1395
1396 typedef struct {
1397 VkStructureType sType;
1398 const void* pNext;
1399 VkImageType imageType;
1400 VkFormat format;
1401 VkExtent3D extent;
1402 uint32_t mipLevels;
1403 uint32_t arraySize;
1404 uint32_t samples;
1405 VkImageTiling tiling;
1406 VkImageUsageFlags usage;
1407 VkImageCreateFlags flags;
1408 } VkImageCreateInfo;
1409
1410 typedef struct {
1411 VkDeviceSize offset;
1412 VkDeviceSize size;
1413 VkDeviceSize rowPitch;
1414 VkDeviceSize depthPitch;
1415 } VkSubresourceLayout;
1416
1417 typedef struct {
1418 VkChannelSwizzle r;
1419 VkChannelSwizzle g;
1420 VkChannelSwizzle b;
1421 VkChannelSwizzle a;
1422 } VkChannelMapping;
1423
1424 typedef struct {
1425 VkImageAspect aspect;
1426 uint32_t baseMipLevel;
1427 uint32_t mipLevels;
1428 uint32_t baseArraySlice;
1429 uint32_t arraySize;
1430 } VkImageSubresourceRange;
1431
1432 typedef struct {
1433 VkStructureType sType;
1434 const void* pNext;
1435 VkImage image;
1436 VkImageViewType viewType;
1437 VkFormat format;
1438 VkChannelMapping channels;
1439 VkImageSubresourceRange subresourceRange;
1440 } VkImageViewCreateInfo;
1441
1442 typedef struct {
1443 VkStructureType sType;
1444 const void* pNext;
1445 VkImage image;
1446 VkFormat format;
1447 uint32_t mipLevel;
1448 uint32_t baseArraySlice;
1449 uint32_t arraySize;
1450 VkAttachmentViewCreateFlags flags;
1451 } VkAttachmentViewCreateInfo;
1452
1453 typedef struct {
1454 VkStructureType sType;
1455 const void* pNext;
1456 size_t codeSize;
1457 const void* pCode;
1458 VkShaderModuleCreateFlags flags;
1459 } VkShaderModuleCreateInfo;
1460
1461 typedef struct {
1462 VkStructureType sType;
1463 const void* pNext;
1464 VkShaderModule module;
1465 const char* pName;
1466 VkShaderCreateFlags flags;
1467 } VkShaderCreateInfo;
1468
1469 typedef struct {
1470 VkStructureType sType;
1471 const void* pNext;
1472 size_t initialSize;
1473 const void* initialData;
1474 size_t maxSize;
1475 } VkPipelineCacheCreateInfo;
1476
1477 typedef struct {
1478 uint32_t constantId;
1479 uint32_t offset;
1480 } VkSpecializationMapEntry;
1481
1482 typedef struct {
1483 uint32_t mapEntryCount;
1484 const VkSpecializationMapEntry* pMap;
1485 const void* pData;
1486 } VkSpecializationInfo;
1487
1488 typedef struct {
1489 VkStructureType sType;
1490 const void* pNext;
1491 VkShaderStage stage;
1492 VkShader shader;
1493 const VkSpecializationInfo* pSpecializationInfo;
1494 } VkPipelineShaderStageCreateInfo;
1495
1496 typedef struct {
1497 uint32_t binding;
1498 uint32_t strideInBytes;
1499 VkVertexInputStepRate stepRate;
1500 } VkVertexInputBindingDescription;
1501
1502 typedef struct {
1503 uint32_t location;
1504 uint32_t binding;
1505 VkFormat format;
1506 uint32_t offsetInBytes;
1507 } VkVertexInputAttributeDescription;
1508
1509 typedef struct {
1510 VkStructureType sType;
1511 const void* pNext;
1512 uint32_t bindingCount;
1513 const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1514 uint32_t attributeCount;
1515 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1516 } VkPipelineVertexInputStateCreateInfo;
1517
1518 typedef struct {
1519 VkStructureType sType;
1520 const void* pNext;
1521 VkPrimitiveTopology topology;
1522 VkBool32 primitiveRestartEnable;
1523 } VkPipelineIaStateCreateInfo;
1524
1525 typedef struct {
1526 VkStructureType sType;
1527 const void* pNext;
1528 uint32_t patchControlPoints;
1529 } VkPipelineTessStateCreateInfo;
1530
1531 typedef struct {
1532 VkStructureType sType;
1533 const void* pNext;
1534 uint32_t viewportCount;
1535 } VkPipelineVpStateCreateInfo;
1536
1537 typedef struct {
1538 VkStructureType sType;
1539 const void* pNext;
1540 VkBool32 depthClipEnable;
1541 VkBool32 rasterizerDiscardEnable;
1542 VkFillMode fillMode;
1543 VkCullMode cullMode;
1544 VkFrontFace frontFace;
1545 } VkPipelineRsStateCreateInfo;
1546
1547 typedef struct {
1548 VkStructureType sType;
1549 const void* pNext;
1550 uint32_t rasterSamples;
1551 VkBool32 sampleShadingEnable;
1552 float minSampleShading;
1553 VkSampleMask sampleMask;
1554 } VkPipelineMsStateCreateInfo;
1555
1556 typedef struct {
1557 VkStencilOp stencilFailOp;
1558 VkStencilOp stencilPassOp;
1559 VkStencilOp stencilDepthFailOp;
1560 VkCompareOp stencilCompareOp;
1561 } VkStencilOpState;
1562
1563 typedef struct {
1564 VkStructureType sType;
1565 const void* pNext;
1566 VkBool32 depthTestEnable;
1567 VkBool32 depthWriteEnable;
1568 VkCompareOp depthCompareOp;
1569 VkBool32 depthBoundsEnable;
1570 VkBool32 stencilTestEnable;
1571 VkStencilOpState front;
1572 VkStencilOpState back;
1573 } VkPipelineDsStateCreateInfo;
1574
1575 typedef struct {
1576 VkBool32 blendEnable;
1577 VkBlend srcBlendColor;
1578 VkBlend destBlendColor;
1579 VkBlendOp blendOpColor;
1580 VkBlend srcBlendAlpha;
1581 VkBlend destBlendAlpha;
1582 VkBlendOp blendOpAlpha;
1583 VkChannelFlags channelWriteMask;
1584 } VkPipelineCbAttachmentState;
1585
1586 typedef struct {
1587 VkStructureType sType;
1588 const void* pNext;
1589 VkBool32 alphaToCoverageEnable;
1590 VkBool32 logicOpEnable;
1591 VkLogicOp logicOp;
1592 uint32_t attachmentCount;
1593 const VkPipelineCbAttachmentState* pAttachments;
1594 } VkPipelineCbStateCreateInfo;
1595
1596 typedef struct {
1597 VkStructureType sType;
1598 const void* pNext;
1599 uint32_t stageCount;
1600 const VkPipelineShaderStageCreateInfo* pStages;
1601 const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
1602 const VkPipelineIaStateCreateInfo* pIaState;
1603 const VkPipelineTessStateCreateInfo* pTessState;
1604 const VkPipelineVpStateCreateInfo* pVpState;
1605 const VkPipelineRsStateCreateInfo* pRsState;
1606 const VkPipelineMsStateCreateInfo* pMsState;
1607 const VkPipelineDsStateCreateInfo* pDsState;
1608 const VkPipelineCbStateCreateInfo* pCbState;
1609 VkPipelineCreateFlags flags;
1610 VkPipelineLayout layout;
1611 VkRenderPass renderPass;
1612 uint32_t subpass;
1613 VkPipeline basePipelineHandle;
1614 int32_t basePipelineIndex;
1615 } VkGraphicsPipelineCreateInfo;
1616
1617 typedef struct {
1618 VkStructureType sType;
1619 const void* pNext;
1620 VkPipelineShaderStageCreateInfo cs;
1621 VkPipelineCreateFlags flags;
1622 VkPipelineLayout layout;
1623 VkPipeline basePipelineHandle;
1624 int32_t basePipelineIndex;
1625 } VkComputePipelineCreateInfo;
1626
1627 typedef struct {
1628 VkShaderStageFlags stageFlags;
1629 uint32_t start;
1630 uint32_t length;
1631 } VkPushConstantRange;
1632
1633 typedef struct {
1634 VkStructureType sType;
1635 const void* pNext;
1636 uint32_t descriptorSetCount;
1637 const VkDescriptorSetLayout* pSetLayouts;
1638 uint32_t pushConstantRangeCount;
1639 const VkPushConstantRange* pPushConstantRanges;
1640 } VkPipelineLayoutCreateInfo;
1641
1642 typedef struct {
1643 VkStructureType sType;
1644 const void* pNext;
1645 VkTexFilter magFilter;
1646 VkTexFilter minFilter;
1647 VkTexMipmapMode mipMode;
1648 VkTexAddress addressU;
1649 VkTexAddress addressV;
1650 VkTexAddress addressW;
1651 float mipLodBias;
1652 uint32_t maxAnisotropy;
1653 VkBool32 compareEnable;
1654 VkCompareOp compareOp;
1655 float minLod;
1656 float maxLod;
1657 VkBorderColor borderColor;
1658 } VkSamplerCreateInfo;
1659
1660 typedef struct {
1661 VkDescriptorType descriptorType;
1662 uint32_t arraySize;
1663 VkShaderStageFlags stageFlags;
1664 const VkSampler* pImmutableSamplers;
1665 } VkDescriptorSetLayoutBinding;
1666
1667 typedef struct {
1668 VkStructureType sType;
1669 const void* pNext;
1670 uint32_t count;
1671 const VkDescriptorSetLayoutBinding* pBinding;
1672 } VkDescriptorSetLayoutCreateInfo;
1673
1674 typedef struct {
1675 VkDescriptorType type;
1676 uint32_t count;
1677 } VkDescriptorTypeCount;
1678
1679 typedef struct {
1680 VkStructureType sType;
1681 const void* pNext;
1682 uint32_t count;
1683 const VkDescriptorTypeCount* pTypeCount;
1684 } VkDescriptorPoolCreateInfo;
1685
1686 typedef struct {
1687 VkBufferView bufferView;
1688 VkSampler sampler;
1689 VkImageView imageView;
1690 VkAttachmentView attachmentView;
1691 VkImageLayout imageLayout;
1692 } VkDescriptorInfo;
1693
1694 typedef struct {
1695 VkStructureType sType;
1696 const void* pNext;
1697 VkDescriptorSet destSet;
1698 uint32_t destBinding;
1699 uint32_t destArrayElement;
1700 uint32_t count;
1701 VkDescriptorType descriptorType;
1702 const VkDescriptorInfo* pDescriptors;
1703 } VkWriteDescriptorSet;
1704
1705 typedef struct {
1706 VkStructureType sType;
1707 const void* pNext;
1708 VkDescriptorSet srcSet;
1709 uint32_t srcBinding;
1710 uint32_t srcArrayElement;
1711 VkDescriptorSet destSet;
1712 uint32_t destBinding;
1713 uint32_t destArrayElement;
1714 uint32_t count;
1715 } VkCopyDescriptorSet;
1716
1717 typedef struct {
1718 float originX;
1719 float originY;
1720 float width;
1721 float height;
1722 float minDepth;
1723 float maxDepth;
1724 } VkViewport;
1725
1726 typedef struct {
1727 int32_t x;
1728 int32_t y;
1729 } VkOffset2D;
1730
1731 typedef struct {
1732 int32_t width;
1733 int32_t height;
1734 } VkExtent2D;
1735
1736 typedef struct {
1737 VkOffset2D offset;
1738 VkExtent2D extent;
1739 } VkRect2D;
1740
1741 typedef struct {
1742 VkStructureType sType;
1743 const void* pNext;
1744 uint32_t viewportAndScissorCount;
1745 const VkViewport* pViewports;
1746 const VkRect2D* pScissors;
1747 } VkDynamicViewportStateCreateInfo;
1748
1749 typedef struct {
1750 VkStructureType sType;
1751 const void* pNext;
1752 float depthBias;
1753 float depthBiasClamp;
1754 float slopeScaledDepthBias;
1755 float lineWidth;
1756 } VkDynamicRasterStateCreateInfo;
1757
1758 typedef struct {
1759 VkStructureType sType;
1760 const void* pNext;
1761 float blendConst[4];
1762 } VkDynamicColorBlendStateCreateInfo;
1763
1764 typedef struct {
1765 VkStructureType sType;
1766 const void* pNext;
1767 float minDepthBounds;
1768 float maxDepthBounds;
1769 uint32_t stencilReadMask;
1770 uint32_t stencilWriteMask;
1771 uint32_t stencilFrontRef;
1772 uint32_t stencilBackRef;
1773 } VkDynamicDepthStencilStateCreateInfo;
1774
1775 typedef struct {
1776 VkAttachmentView view;
1777 VkImageLayout layout;
1778 } VkAttachmentBindInfo;
1779
1780 typedef struct {
1781 VkStructureType sType;
1782 const void* pNext;
1783 VkRenderPass renderPass;
1784 uint32_t attachmentCount;
1785 const VkAttachmentBindInfo* pAttachments;
1786 uint32_t width;
1787 uint32_t height;
1788 uint32_t layers;
1789 } VkFramebufferCreateInfo;
1790
1791 typedef struct {
1792 VkStructureType sType;
1793 const void* pNext;
1794 VkFormat format;
1795 uint32_t samples;
1796 VkAttachmentLoadOp loadOp;
1797 VkAttachmentStoreOp storeOp;
1798 VkAttachmentLoadOp stencilLoadOp;
1799 VkAttachmentStoreOp stencilStoreOp;
1800 VkImageLayout initialLayout;
1801 VkImageLayout finalLayout;
1802 } VkAttachmentDescription;
1803
1804 typedef struct {
1805 uint32_t attachment;
1806 VkImageLayout layout;
1807 } VkAttachmentReference;
1808
1809 typedef struct {
1810 VkStructureType sType;
1811 const void* pNext;
1812 VkPipelineBindPoint pipelineBindPoint;
1813 VkSubpassDescriptionFlags flags;
1814 uint32_t inputCount;
1815 const VkAttachmentReference* inputAttachments;
1816 uint32_t colorCount;
1817 const VkAttachmentReference* colorAttachments;
1818 const VkAttachmentReference* resolveAttachments;
1819 VkAttachmentReference depthStencilAttachment;
1820 uint32_t preserveCount;
1821 const VkAttachmentReference* preserveAttachments;
1822 } VkSubpassDescription;
1823
1824 typedef struct {
1825 VkStructureType sType;
1826 const void* pNext;
1827 uint32_t srcSubpass;
1828 uint32_t dstSubpass;
1829 VkPipelineStageFlags srcStageMask;
1830 VkPipelineStageFlags destStageMask;
1831 VkMemoryOutputFlags outputMask;
1832 VkMemoryInputFlags inputMask;
1833 VkBool32 byRegion;
1834 } VkSubpassDependency;
1835
1836 typedef struct {
1837 VkStructureType sType;
1838 const void* pNext;
1839 uint32_t attachmentCount;
1840 const VkAttachmentDescription* pAttachments;
1841 uint32_t subpassCount;
1842 const VkSubpassDescription* pSubpasses;
1843 uint32_t dependencyCount;
1844 const VkSubpassDependency* pDependencies;
1845 } VkRenderPassCreateInfo;
1846
1847 typedef struct {
1848 VkStructureType sType;
1849 const void* pNext;
1850 uint32_t queueNodeIndex;
1851 VkCmdBufferLevel level;
1852 VkCmdBufferCreateFlags flags;
1853 } VkCmdBufferCreateInfo;
1854
1855 typedef struct {
1856 VkStructureType sType;
1857 const void* pNext;
1858 VkCmdBufferOptimizeFlags flags;
1859 VkRenderPass renderPass;
1860 VkFramebuffer framebuffer;
1861 } VkCmdBufferBeginInfo;
1862
1863 typedef struct {
1864 VkDeviceSize srcOffset;
1865 VkDeviceSize destOffset;
1866 VkDeviceSize copySize;
1867 } VkBufferCopy;
1868
1869 typedef struct {
1870 VkImageSubresource srcSubresource;
1871 VkOffset3D srcOffset;
1872 VkImageSubresource destSubresource;
1873 VkOffset3D destOffset;
1874 VkExtent3D extent;
1875 } VkImageCopy;
1876
1877 typedef struct {
1878 VkImageSubresource srcSubresource;
1879 VkOffset3D srcOffset;
1880 VkExtent3D srcExtent;
1881 VkImageSubresource destSubresource;
1882 VkOffset3D destOffset;
1883 VkExtent3D destExtent;
1884 } VkImageBlit;
1885
1886 typedef struct {
1887 VkDeviceSize bufferOffset;
1888 uint32_t bufferRowLength;
1889 uint32_t bufferImageHeight;
1890 VkImageSubresource imageSubresource;
1891 VkOffset3D imageOffset;
1892 VkExtent3D imageExtent;
1893 } VkBufferImageCopy;
1894
1895 typedef union {
1896 float f32[4];
1897 int32_t s32[4];
1898 uint32_t u32[4];
1899 } VkClearColorValue;
1900
1901 typedef struct {
1902 VkOffset3D offset;
1903 VkExtent3D extent;
1904 } VkRect3D;
1905
1906 typedef struct {
1907 VkImageSubresource srcSubresource;
1908 VkOffset3D srcOffset;
1909 VkImageSubresource destSubresource;
1910 VkOffset3D destOffset;
1911 VkExtent3D extent;
1912 } VkImageResolve;
1913
1914 typedef struct {
1915 float depth;
1916 uint32_t stencil;
1917 } VkClearDepthStencilValue;
1918
1919 typedef union {
1920 VkClearColorValue color;
1921 VkClearDepthStencilValue ds;
1922 } VkClearValue;
1923
1924 typedef struct {
1925 VkStructureType sType;
1926 const void* pNext;
1927 VkRenderPass renderPass;
1928 VkFramebuffer framebuffer;
1929 VkRect2D renderArea;
1930 uint32_t attachmentCount;
1931 const VkClearValue* pAttachmentClearValues;
1932 } VkRenderPassBeginInfo;
1933
1934 typedef struct {
1935 VkStructureType sType;
1936 const void* pNext;
1937 VkMemoryOutputFlags outputMask;
1938 VkMemoryInputFlags inputMask;
1939 VkBuffer buffer;
1940 VkDeviceSize offset;
1941 VkDeviceSize size;
1942 } VkBufferMemoryBarrier;
1943
1944 typedef struct {
1945 uint32_t x;
1946 uint32_t y;
1947 uint32_t z;
1948 } VkDispatchIndirectCmd;
1949
1950 typedef struct {
1951 uint32_t indexCount;
1952 uint32_t instanceCount;
1953 uint32_t firstIndex;
1954 int32_t vertexOffset;
1955 uint32_t firstInstance;
1956 } VkDrawIndexedIndirectCmd;
1957
1958 typedef struct {
1959 uint32_t vertexCount;
1960 uint32_t instanceCount;
1961 uint32_t firstVertex;
1962 uint32_t firstInstance;
1963 } VkDrawIndirectCmd;
1964
1965 typedef struct {
1966 VkStructureType sType;
1967 const void* pNext;
1968 VkMemoryOutputFlags outputMask;
1969 VkMemoryInputFlags inputMask;
1970 VkImageLayout oldLayout;
1971 VkImageLayout newLayout;
1972 VkImage image;
1973 VkImageSubresourceRange subresourceRange;
1974 } VkImageMemoryBarrier;
1975
1976 typedef struct {
1977 VkStructureType sType;
1978 const void* pNext;
1979 uint32_t layerCount;
1980 const char *const* ppActiveLayerNames;
1981 } VkLayerCreateInfo;
1982
1983 typedef struct {
1984 VkStructureType sType;
1985 const void* pNext;
1986 VkMemoryOutputFlags outputMask;
1987 VkMemoryInputFlags inputMask;
1988 } VkMemoryBarrier;
1989
1990
1991 typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
1992 typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
1993 typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
1994 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
1995 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatInfo)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatInfo);
1996 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLimits)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits);
1997 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
1998 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount);
1999 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueProperties)(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties);
2000 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperies);
2001 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
2002 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
2003 typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
2004 typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
2005 typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionCount)(uint32_t* pCount);
2006 typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(uint32_t extensionIndex, VkExtensionProperties* pProperties);
2007 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount);
2008 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, uint32_t extensionIndex, VkExtensionProperties* pProperties);
2009 typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalDevice physicalDevice, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved);
2010 typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue);
2011 typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
2012 typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
2013 typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
2014 typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
2015 typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem);
2016 typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
2017 typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
2018 typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
2019 typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
2020 typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object);
2021 typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
2022 typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
2023 typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
2024 typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
2025 typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
2026 typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
2027 typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
2028 typedef VkResult (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence);
2029 typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
2030 typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
2031 typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
2032 typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
2033 typedef VkResult (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore);
2034 typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore);
2035 typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore);
2036 typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
2037 typedef VkResult (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event);
2038 typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
2039 typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
2040 typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
2041 typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
2042 typedef VkResult (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool);
2043 typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags);
2044 typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
2045 typedef VkResult (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer);
2046 typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
2047 typedef VkResult (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
2048 typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
2049 typedef VkResult (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
2050 typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
2051 typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
2052 typedef VkResult (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
2053 typedef VkResult (VKAPI *PFN_vkCreateAttachmentView)(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView);
2054 typedef VkResult (VKAPI *PFN_vkDestroyAttachmentView)(VkDevice device, VkAttachmentView attachmentView);
2055 typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
2056 typedef VkResult (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule);
2057 typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
2058 typedef VkResult (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader);
2059 typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
2060 typedef VkResult (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
2061 typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache);
2062 typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData);
2063 typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
2064 typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
2065 typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
2066 typedef VkResult (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline);
2067 typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
2068 typedef VkResult (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout);
2069 typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
2070 typedef VkResult (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler);
2071 typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
2072 typedef VkResult (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
2073 typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
2074 typedef VkResult (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
2075 typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
2076 typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount);
2077 typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
2078 typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState);
2079 typedef VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState);
2080 typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState);
2081 typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState);
2082 typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState);
2083 typedef VkResult (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState);
2084 typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState);
2085 typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthStencilState)(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState);
2086 typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
2087 typedef VkResult (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
2088 typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
2089 typedef VkResult (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
2090 typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
2091 typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
2092 typedef VkResult (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer);
2093 typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
2094 typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
2095 typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer);
2096 typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
2097 typedef void (VKAPI *PFN_vkCmdBindDynamicViewportState)(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState);
2098 typedef void (VKAPI *PFN_vkCmdBindDynamicRasterState)(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState);
2099 typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState);
2100 typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState);
2101 typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
2102 typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
2103 typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
2104 typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
2105 typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
2106 typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
2107 typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
2108 typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
2109 typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
2110 typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
2111 typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
2112 typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter);
2113 typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
2114 typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
2115 typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
2116 typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
2117 typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2118 typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2119 typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects);
2120 typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects);
2121 typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
2122 typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
2123 typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
2124 typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
2125 typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers);
2126 typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
2127 typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
2128 typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
2129 typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset);
2130 typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
2131 typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
2132 typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
2133 typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
2134 typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer);
2135 typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers);
2136
2137 #ifdef VK_PROTOTYPES
2138 VkResult VKAPI vkCreateInstance(
2139 const VkInstanceCreateInfo* pCreateInfo,
2140 VkInstance* pInstance);
2141
2142 VkResult VKAPI vkDestroyInstance(
2143 VkInstance instance);
2144
2145 VkResult VKAPI vkEnumeratePhysicalDevices(
2146 VkInstance instance,
2147 uint32_t* pPhysicalDeviceCount,
2148 VkPhysicalDevice* pPhysicalDevices);
2149
2150 VkResult VKAPI vkGetPhysicalDeviceFeatures(
2151 VkPhysicalDevice physicalDevice,
2152 VkPhysicalDeviceFeatures* pFeatures);
2153
2154 VkResult VKAPI vkGetPhysicalDeviceFormatInfo(
2155 VkPhysicalDevice physicalDevice,
2156 VkFormat format,
2157 VkFormatProperties* pFormatInfo);
2158
2159 VkResult VKAPI vkGetPhysicalDeviceLimits(
2160 VkPhysicalDevice physicalDevice,
2161 VkPhysicalDeviceLimits* pLimits);
2162
2163 VkResult VKAPI vkGetPhysicalDeviceProperties(
2164 VkPhysicalDevice physicalDevice,
2165 VkPhysicalDeviceProperties* pProperties);
2166
2167 VkResult VKAPI vkGetPhysicalDeviceQueueCount(
2168 VkPhysicalDevice physicalDevice,
2169 uint32_t* pCount);
2170
2171 VkResult VKAPI vkGetPhysicalDeviceQueueProperties(
2172 VkPhysicalDevice physicalDevice,
2173 uint32_t count,
2174 VkPhysicalDeviceQueueProperties* pQueueProperties);
2175
2176 VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
2177 VkPhysicalDevice physicalDevice,
2178 VkPhysicalDeviceMemoryProperties* pMemoryProperies);
2179
2180 PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(
2181 VkInstance instance,
2182 const char* pName);
2183
2184 PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
2185 VkDevice device,
2186 const char* pName);
2187
2188 VkResult VKAPI vkCreateDevice(
2189 VkPhysicalDevice physicalDevice,
2190 const VkDeviceCreateInfo* pCreateInfo,
2191 VkDevice* pDevice);
2192
2193 VkResult VKAPI vkDestroyDevice(
2194 VkDevice device);
2195
2196 VkResult VKAPI vkGetGlobalExtensionCount(
2197 uint32_t* pCount);
2198
2199 VkResult VKAPI vkGetGlobalExtensionProperties(
2200 uint32_t extensionIndex,
2201 VkExtensionProperties* pProperties);
2202
2203 VkResult VKAPI vkGetPhysicalDeviceExtensionCount(
2204 VkPhysicalDevice physicalDevice,
2205 uint32_t* pCount);
2206
2207 VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
2208 VkPhysicalDevice physicalDevice,
2209 uint32_t extensionIndex,
2210 VkExtensionProperties* pProperties);
2211
2212 VkResult VKAPI vkEnumerateLayers(
2213 VkPhysicalDevice physicalDevice,
2214 size_t maxStringSize,
2215 size_t* pLayerCount,
2216 char* const* pOutLayers,
2217 void* pReserved);
2218
2219 VkResult VKAPI vkGetDeviceQueue(
2220 VkDevice device,
2221 uint32_t queueNodeIndex,
2222 uint32_t queueIndex,
2223 VkQueue* pQueue);
2224
2225 VkResult VKAPI vkQueueSubmit(
2226 VkQueue queue,
2227 uint32_t cmdBufferCount,
2228 const VkCmdBuffer* pCmdBuffers,
2229 VkFence fence);
2230
2231 VkResult VKAPI vkQueueWaitIdle(
2232 VkQueue queue);
2233
2234 VkResult VKAPI vkDeviceWaitIdle(
2235 VkDevice device);
2236
2237 VkResult VKAPI vkAllocMemory(
2238 VkDevice device,
2239 const VkMemoryAllocInfo* pAllocInfo,
2240 VkDeviceMemory* pMem);
2241
2242 VkResult VKAPI vkFreeMemory(
2243 VkDevice device,
2244 VkDeviceMemory mem);
2245
2246 VkResult VKAPI vkMapMemory(
2247 VkDevice device,
2248 VkDeviceMemory mem,
2249 VkDeviceSize offset,
2250 VkDeviceSize size,
2251 VkMemoryMapFlags flags,
2252 void** ppData);
2253
2254 VkResult VKAPI vkUnmapMemory(
2255 VkDevice device,
2256 VkDeviceMemory mem);
2257
2258 VkResult VKAPI vkFlushMappedMemoryRanges(
2259 VkDevice device,
2260 uint32_t memRangeCount,
2261 const VkMappedMemoryRange* pMemRanges);
2262
2263 VkResult VKAPI vkInvalidateMappedMemoryRanges(
2264 VkDevice device,
2265 uint32_t memRangeCount,
2266 const VkMappedMemoryRange* pMemRanges);
2267
2268 VkResult VKAPI vkDestroyObject(
2269 VkDevice device,
2270 VkObjectType objType,
2271 VkObject object);
2272
2273 VkResult VKAPI vkBindBufferMemory(
2274 VkDevice device,
2275 VkBuffer buffer,
2276 VkDeviceMemory mem,
2277 VkDeviceSize memOffset);
2278
2279 VkResult VKAPI vkBindImageMemory(
2280 VkDevice device,
2281 VkImage image,
2282 VkDeviceMemory mem,
2283 VkDeviceSize memOffset);
2284
2285 VkResult VKAPI vkGetBufferMemoryRequirements(
2286 VkDevice device,
2287 VkBuffer buffer,
2288 VkMemoryRequirements* pMemoryRequirements);
2289
2290 VkResult VKAPI vkGetImageMemoryRequirements(
2291 VkDevice device,
2292 VkImage image,
2293 VkMemoryRequirements* pMemoryRequirements);
2294
2295 VkResult VKAPI vkQueueBindSparseBufferMemory(
2296 VkQueue queue,
2297 VkBuffer buffer,
2298 VkDeviceSize rangeOffset,
2299 VkDeviceSize rangeSize,
2300 VkDeviceMemory mem,
2301 VkDeviceSize memOffset);
2302
2303 VkResult VKAPI vkQueueBindSparseImageMemory(
2304 VkQueue queue,
2305 VkImage image,
2306 const VkImageMemoryBindInfo* pBindInfo,
2307 VkDeviceMemory mem,
2308 VkDeviceSize memOffset);
2309
2310 VkResult VKAPI vkCreateFence(
2311 VkDevice device,
2312 const VkFenceCreateInfo* pCreateInfo,
2313 VkFence* pFence);
2314
2315 VkResult VKAPI vkDestroyFence(
2316 VkDevice device,
2317 VkFence fence);
2318
2319 VkResult VKAPI vkResetFences(
2320 VkDevice device,
2321 uint32_t fenceCount,
2322 const VkFence* pFences);
2323
2324 VkResult VKAPI vkGetFenceStatus(
2325 VkDevice device,
2326 VkFence fence);
2327
2328 VkResult VKAPI vkWaitForFences(
2329 VkDevice device,
2330 uint32_t fenceCount,
2331 const VkFence* pFences,
2332 VkBool32 waitAll,
2333 uint64_t timeout);
2334
2335 VkResult VKAPI vkCreateSemaphore(
2336 VkDevice device,
2337 const VkSemaphoreCreateInfo* pCreateInfo,
2338 VkSemaphore* pSemaphore);
2339
2340 VkResult VKAPI vkDestroySemaphore(
2341 VkDevice device,
2342 VkSemaphore semaphore);
2343
2344 VkResult VKAPI vkQueueSignalSemaphore(
2345 VkQueue queue,
2346 VkSemaphore semaphore);
2347
2348 VkResult VKAPI vkQueueWaitSemaphore(
2349 VkQueue queue,
2350 VkSemaphore semaphore);
2351
2352 VkResult VKAPI vkCreateEvent(
2353 VkDevice device,
2354 const VkEventCreateInfo* pCreateInfo,
2355 VkEvent* pEvent);
2356
2357 VkResult VKAPI vkDestroyEvent(
2358 VkDevice device,
2359 VkEvent event);
2360
2361 VkResult VKAPI vkGetEventStatus(
2362 VkDevice device,
2363 VkEvent event);
2364
2365 VkResult VKAPI vkSetEvent(
2366 VkDevice device,
2367 VkEvent event);
2368
2369 VkResult VKAPI vkResetEvent(
2370 VkDevice device,
2371 VkEvent event);
2372
2373 VkResult VKAPI vkCreateQueryPool(
2374 VkDevice device,
2375 const VkQueryPoolCreateInfo* pCreateInfo,
2376 VkQueryPool* pQueryPool);
2377
2378 VkResult VKAPI vkDestroyQueryPool(
2379 VkDevice device,
2380 VkQueryPool queryPool);
2381
2382 VkResult VKAPI vkGetQueryPoolResults(
2383 VkDevice device,
2384 VkQueryPool queryPool,
2385 uint32_t startQuery,
2386 uint32_t queryCount,
2387 size_t* pDataSize,
2388 void* pData,
2389 VkQueryResultFlags flags);
2390
2391 VkResult VKAPI vkCreateBuffer(
2392 VkDevice device,
2393 const VkBufferCreateInfo* pCreateInfo,
2394 VkBuffer* pBuffer);
2395
2396 VkResult VKAPI vkDestroyBuffer(
2397 VkDevice device,
2398 VkBuffer buffer);
2399
2400 VkResult VKAPI vkCreateBufferView(
2401 VkDevice device,
2402 const VkBufferViewCreateInfo* pCreateInfo,
2403 VkBufferView* pView);
2404
2405 VkResult VKAPI vkDestroyBufferView(
2406 VkDevice device,
2407 VkBufferView bufferView);
2408
2409 VkResult VKAPI vkCreateImage(
2410 VkDevice device,
2411 const VkImageCreateInfo* pCreateInfo,
2412 VkImage* pImage);
2413
2414 VkResult VKAPI vkDestroyImage(
2415 VkDevice device,
2416 VkImage image);
2417
2418 VkResult VKAPI vkGetImageSubresourceLayout(
2419 VkDevice device,
2420 VkImage image,
2421 const VkImageSubresource* pSubresource,
2422 VkSubresourceLayout* pLayout);
2423
2424 VkResult VKAPI vkCreateImageView(
2425 VkDevice device,
2426 const VkImageViewCreateInfo* pCreateInfo,
2427 VkImageView* pView);
2428
2429 VkResult VKAPI vkDestroyImageView(
2430 VkDevice device,
2431 VkImageView imageView);
2432
2433 VkResult VKAPI vkCreateAttachmentView(
2434 VkDevice device,
2435 const VkAttachmentViewCreateInfo* pCreateInfo,
2436 VkAttachmentView* pView);
2437
2438 VkResult VKAPI vkDestroyAttachmentView(
2439 VkDevice device,
2440 VkAttachmentView attachmentView);
2441
2442 VkResult VKAPI vkCreateShaderModule(
2443 VkDevice device,
2444 const VkShaderModuleCreateInfo* pCreateInfo,
2445 VkShaderModule* pShaderModule);
2446
2447 VkResult VKAPI vkDestroyShaderModule(
2448 VkDevice device,
2449 VkShaderModule shaderModule);
2450
2451 VkResult VKAPI vkCreateShader(
2452 VkDevice device,
2453 const VkShaderCreateInfo* pCreateInfo,
2454 VkShader* pShader);
2455
2456 VkResult VKAPI vkDestroyShader(
2457 VkDevice device,
2458 VkShader shader);
2459
2460 VkResult VKAPI vkCreatePipelineCache(
2461 VkDevice device,
2462 const VkPipelineCacheCreateInfo* pCreateInfo,
2463 VkPipelineCache* pPipelineCache);
2464
2465 VkResult VKAPI vkDestroyPipelineCache(
2466 VkDevice device,
2467 VkPipelineCache pipelineCache);
2468
2469 size_t VKAPI vkGetPipelineCacheSize(
2470 VkDevice device,
2471 VkPipelineCache pipelineCache);
2472
2473 VkResult VKAPI vkGetPipelineCacheData(
2474 VkDevice device,
2475 VkPipelineCache pipelineCache,
2476 void* pData);
2477
2478 VkResult VKAPI vkMergePipelineCaches(
2479 VkDevice device,
2480 VkPipelineCache destCache,
2481 uint32_t srcCacheCount,
2482 const VkPipelineCache* pSrcCaches);
2483
2484 VkResult VKAPI vkCreateGraphicsPipelines(
2485 VkDevice device,
2486 VkPipelineCache pipelineCache,
2487 uint32_t count,
2488 const VkGraphicsPipelineCreateInfo* pCreateInfos,
2489 VkPipeline* pPipelines);
2490
2491 VkResult VKAPI vkCreateComputePipelines(
2492 VkDevice device,
2493 VkPipelineCache pipelineCache,
2494 uint32_t count,
2495 const VkComputePipelineCreateInfo* pCreateInfos,
2496 VkPipeline* pPipelines);
2497
2498 VkResult VKAPI vkDestroyPipeline(
2499 VkDevice device,
2500 VkPipeline pipeline);
2501
2502 VkResult VKAPI vkCreatePipelineLayout(
2503 VkDevice device,
2504 const VkPipelineLayoutCreateInfo* pCreateInfo,
2505 VkPipelineLayout* pPipelineLayout);
2506
2507 VkResult VKAPI vkDestroyPipelineLayout(
2508 VkDevice device,
2509 VkPipelineLayout pipelineLayout);
2510
2511 VkResult VKAPI vkCreateSampler(
2512 VkDevice device,
2513 const VkSamplerCreateInfo* pCreateInfo,
2514 VkSampler* pSampler);
2515
2516 VkResult VKAPI vkDestroySampler(
2517 VkDevice device,
2518 VkSampler sampler);
2519
2520 VkResult VKAPI vkCreateDescriptorSetLayout(
2521 VkDevice device,
2522 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
2523 VkDescriptorSetLayout* pSetLayout);
2524
2525 VkResult VKAPI vkDestroyDescriptorSetLayout(
2526 VkDevice device,
2527 VkDescriptorSetLayout descriptorSetLayout);
2528
2529 VkResult VKAPI vkCreateDescriptorPool(
2530 VkDevice device,
2531 VkDescriptorPoolUsage poolUsage,
2532 uint32_t maxSets,
2533 const VkDescriptorPoolCreateInfo* pCreateInfo,
2534 VkDescriptorPool* pDescriptorPool);
2535
2536 VkResult VKAPI vkDestroyDescriptorPool(
2537 VkDevice device,
2538 VkDescriptorPool descriptorPool);
2539
2540 VkResult VKAPI vkResetDescriptorPool(
2541 VkDevice device,
2542 VkDescriptorPool descriptorPool);
2543
2544 VkResult VKAPI vkAllocDescriptorSets(
2545 VkDevice device,
2546 VkDescriptorPool descriptorPool,
2547 VkDescriptorSetUsage setUsage,
2548 uint32_t count,
2549 const VkDescriptorSetLayout* pSetLayouts,
2550 VkDescriptorSet* pDescriptorSets,
2551 uint32_t* pCount);
2552
2553 VkResult VKAPI vkUpdateDescriptorSets(
2554 VkDevice device,
2555 uint32_t writeCount,
2556 const VkWriteDescriptorSet* pDescriptorWrites,
2557 uint32_t copyCount,
2558 const VkCopyDescriptorSet* pDescriptorCopies);
2559
2560 VkResult VKAPI vkCreateDynamicViewportState(
2561 VkDevice device,
2562 const VkDynamicViewportStateCreateInfo* pCreateInfo,
2563 VkDynamicViewportState* pState);
2564
2565 VkResult VKAPI vkDestroyDynamicViewportState(
2566 VkDevice device,
2567 VkDynamicViewportState dynamicViewportState);
2568
2569 VkResult VKAPI vkCreateDynamicRasterState(
2570 VkDevice device,
2571 const VkDynamicRasterStateCreateInfo* pCreateInfo,
2572 VkDynamicRasterState* pState);
2573
2574 VkResult VKAPI vkDestroyDynamicRasterState(
2575 VkDevice device,
2576 VkDynamicRasterState dynamicRasterState);
2577
2578 VkResult VKAPI vkCreateDynamicColorBlendState(
2579 VkDevice device,
2580 const VkDynamicColorBlendStateCreateInfo* pCreateInfo,
2581 VkDynamicColorBlendState* pState);
2582
2583 VkResult VKAPI vkDestroyDynamicColorBlendState(
2584 VkDevice device,
2585 VkDynamicColorBlendState dynamicColorBlendState);
2586
2587 VkResult VKAPI vkCreateDynamicDepthStencilState(
2588 VkDevice device,
2589 const VkDynamicDepthStencilStateCreateInfo* pCreateInfo,
2590 VkDynamicDepthStencilState* pState);
2591
2592 VkResult VKAPI vkDestroyDynamicDepthStencilState(
2593 VkDevice device,
2594 VkDynamicDepthStencilState dynamicDepthStencilState);
2595
2596 VkResult VKAPI vkCreateFramebuffer(
2597 VkDevice device,
2598 const VkFramebufferCreateInfo* pCreateInfo,
2599 VkFramebuffer* pFramebuffer);
2600
2601 VkResult VKAPI vkDestroyFramebuffer(
2602 VkDevice device,
2603 VkFramebuffer framebuffer);
2604
2605 VkResult VKAPI vkCreateRenderPass(
2606 VkDevice device,
2607 const VkRenderPassCreateInfo* pCreateInfo,
2608 VkRenderPass* pRenderPass);
2609
2610 VkResult VKAPI vkDestroyRenderPass(
2611 VkDevice device,
2612 VkRenderPass renderPass);
2613
2614 VkResult VKAPI vkGetRenderAreaGranularity(
2615 VkDevice device,
2616 VkRenderPass renderPass,
2617 VkExtent2D* pGranularity);
2618
2619 VkResult VKAPI vkCreateCommandBuffer(
2620 VkDevice device,
2621 const VkCmdBufferCreateInfo* pCreateInfo,
2622 VkCmdBuffer* pCmdBuffer);
2623
2624 VkResult VKAPI vkDestroyCommandBuffer(
2625 VkDevice device,
2626 VkCmdBuffer commandBuffer);
2627
2628 VkResult VKAPI vkBeginCommandBuffer(
2629 VkCmdBuffer cmdBuffer,
2630 const VkCmdBufferBeginInfo* pBeginInfo);
2631
2632 VkResult VKAPI vkEndCommandBuffer(
2633 VkCmdBuffer cmdBuffer);
2634
2635 VkResult VKAPI vkResetCommandBuffer(
2636 VkCmdBuffer cmdBuffer);
2637
2638 void VKAPI vkCmdBindPipeline(
2639 VkCmdBuffer cmdBuffer,
2640 VkPipelineBindPoint pipelineBindPoint,
2641 VkPipeline pipeline);
2642
2643 void VKAPI vkCmdBindDynamicViewportState(
2644 VkCmdBuffer cmdBuffer,
2645 VkDynamicViewportState dynamicViewportState);
2646
2647 void VKAPI vkCmdBindDynamicRasterState(
2648 VkCmdBuffer cmdBuffer,
2649 VkDynamicRasterState dynamicRasterState);
2650
2651 void VKAPI vkCmdBindDynamicColorBlendState(
2652 VkCmdBuffer cmdBuffer,
2653 VkDynamicColorBlendState dynamicColorBlendState);
2654
2655 void VKAPI vkCmdBindDynamicDepthStencilState(
2656 VkCmdBuffer cmdBuffer,
2657 VkDynamicDepthStencilState dynamicDepthStencilState);
2658
2659 void VKAPI vkCmdBindDescriptorSets(
2660 VkCmdBuffer cmdBuffer,
2661 VkPipelineBindPoint pipelineBindPoint,
2662 VkPipelineLayout layout,
2663 uint32_t firstSet,
2664 uint32_t setCount,
2665 const VkDescriptorSet* pDescriptorSets,
2666 uint32_t dynamicOffsetCount,
2667 const uint32_t* pDynamicOffsets);
2668
2669 void VKAPI vkCmdBindIndexBuffer(
2670 VkCmdBuffer cmdBuffer,
2671 VkBuffer buffer,
2672 VkDeviceSize offset,
2673 VkIndexType indexType);
2674
2675 void VKAPI vkCmdBindVertexBuffers(
2676 VkCmdBuffer cmdBuffer,
2677 uint32_t startBinding,
2678 uint32_t bindingCount,
2679 const VkBuffer* pBuffers,
2680 const VkDeviceSize* pOffsets);
2681
2682 void VKAPI vkCmdDraw(
2683 VkCmdBuffer cmdBuffer,
2684 uint32_t firstVertex,
2685 uint32_t vertexCount,
2686 uint32_t firstInstance,
2687 uint32_t instanceCount);
2688
2689 void VKAPI vkCmdDrawIndexed(
2690 VkCmdBuffer cmdBuffer,
2691 uint32_t firstIndex,
2692 uint32_t indexCount,
2693 int32_t vertexOffset,
2694 uint32_t firstInstance,
2695 uint32_t instanceCount);
2696
2697 void VKAPI vkCmdDrawIndirect(
2698 VkCmdBuffer cmdBuffer,
2699 VkBuffer buffer,
2700 VkDeviceSize offset,
2701 uint32_t count,
2702 uint32_t stride);
2703
2704 void VKAPI vkCmdDrawIndexedIndirect(
2705 VkCmdBuffer cmdBuffer,
2706 VkBuffer buffer,
2707 VkDeviceSize offset,
2708 uint32_t count,
2709 uint32_t stride);
2710
2711 void VKAPI vkCmdDispatch(
2712 VkCmdBuffer cmdBuffer,
2713 uint32_t x,
2714 uint32_t y,
2715 uint32_t z);
2716
2717 void VKAPI vkCmdDispatchIndirect(
2718 VkCmdBuffer cmdBuffer,
2719 VkBuffer buffer,
2720 VkDeviceSize offset);
2721
2722 void VKAPI vkCmdCopyBuffer(
2723 VkCmdBuffer cmdBuffer,
2724 VkBuffer srcBuffer,
2725 VkBuffer destBuffer,
2726 uint32_t regionCount,
2727 const VkBufferCopy* pRegions);
2728
2729 void VKAPI vkCmdCopyImage(
2730 VkCmdBuffer cmdBuffer,
2731 VkImage srcImage,
2732 VkImageLayout srcImageLayout,
2733 VkImage destImage,
2734 VkImageLayout destImageLayout,
2735 uint32_t regionCount,
2736 const VkImageCopy* pRegions);
2737
2738 void VKAPI vkCmdBlitImage(
2739 VkCmdBuffer cmdBuffer,
2740 VkImage srcImage,
2741 VkImageLayout srcImageLayout,
2742 VkImage destImage,
2743 VkImageLayout destImageLayout,
2744 uint32_t regionCount,
2745 const VkImageBlit* pRegions,
2746 VkTexFilter filter);
2747
2748 void VKAPI vkCmdCopyBufferToImage(
2749 VkCmdBuffer cmdBuffer,
2750 VkBuffer srcBuffer,
2751 VkImage destImage,
2752 VkImageLayout destImageLayout,
2753 uint32_t regionCount,
2754 const VkBufferImageCopy* pRegions);
2755
2756 void VKAPI vkCmdCopyImageToBuffer(
2757 VkCmdBuffer cmdBuffer,
2758 VkImage srcImage,
2759 VkImageLayout srcImageLayout,
2760 VkBuffer destBuffer,
2761 uint32_t regionCount,
2762 const VkBufferImageCopy* pRegions);
2763
2764 void VKAPI vkCmdUpdateBuffer(
2765 VkCmdBuffer cmdBuffer,
2766 VkBuffer destBuffer,
2767 VkDeviceSize destOffset,
2768 VkDeviceSize dataSize,
2769 const uint32_t* pData);
2770
2771 void VKAPI vkCmdFillBuffer(
2772 VkCmdBuffer cmdBuffer,
2773 VkBuffer destBuffer,
2774 VkDeviceSize destOffset,
2775 VkDeviceSize fillSize,
2776 uint32_t data);
2777
2778 void VKAPI vkCmdClearColorImage(
2779 VkCmdBuffer cmdBuffer,
2780 VkImage image,
2781 VkImageLayout imageLayout,
2782 const VkClearColorValue* pColor,
2783 uint32_t rangeCount,
2784 const VkImageSubresourceRange* pRanges);
2785
2786 void VKAPI vkCmdClearDepthStencilImage(
2787 VkCmdBuffer cmdBuffer,
2788 VkImage image,
2789 VkImageLayout imageLayout,
2790 float depth,
2791 uint32_t stencil,
2792 uint32_t rangeCount,
2793 const VkImageSubresourceRange* pRanges);
2794
2795 void VKAPI vkCmdClearColorAttachment(
2796 VkCmdBuffer cmdBuffer,
2797 uint32_t colorAttachment,
2798 VkImageLayout imageLayout,
2799 const VkClearColorValue* pColor,
2800 uint32_t rectCount,
2801 const VkRect3D* pRects);
2802
2803 void VKAPI vkCmdClearDepthStencilAttachment(
2804 VkCmdBuffer cmdBuffer,
2805 VkImageAspectFlags imageAspectMask,
2806 VkImageLayout imageLayout,
2807 float depth,
2808 uint32_t stencil,
2809 uint32_t rectCount,
2810 const VkRect3D* pRects);
2811
2812 void VKAPI vkCmdResolveImage(
2813 VkCmdBuffer cmdBuffer,
2814 VkImage srcImage,
2815 VkImageLayout srcImageLayout,
2816 VkImage destImage,
2817 VkImageLayout destImageLayout,
2818 uint32_t regionCount,
2819 const VkImageResolve* pRegions);
2820
2821 void VKAPI vkCmdSetEvent(
2822 VkCmdBuffer cmdBuffer,
2823 VkEvent event,
2824 VkPipelineStageFlags stageMask);
2825
2826 void VKAPI vkCmdResetEvent(
2827 VkCmdBuffer cmdBuffer,
2828 VkEvent event,
2829 VkPipelineStageFlags stageMask);
2830
2831 void VKAPI vkCmdWaitEvents(
2832 VkCmdBuffer cmdBuffer,
2833 uint32_t eventCount,
2834 const VkEvent* pEvents,
2835 VkPipelineStageFlags srcStageMask,
2836 VkPipelineStageFlags destStageMask,
2837 uint32_t memBarrierCount,
2838 const void* const* ppMemBarriers);
2839
2840 void VKAPI vkCmdPipelineBarrier(
2841 VkCmdBuffer cmdBuffer,
2842 VkPipelineStageFlags srcStageMask,
2843 VkPipelineStageFlags destStageMask,
2844 VkBool32 byRegion,
2845 uint32_t memBarrierCount,
2846 const void* const* ppMemBarriers);
2847
2848 void VKAPI vkCmdBeginQuery(
2849 VkCmdBuffer cmdBuffer,
2850 VkQueryPool queryPool,
2851 uint32_t slot,
2852 VkQueryControlFlags flags);
2853
2854 void VKAPI vkCmdEndQuery(
2855 VkCmdBuffer cmdBuffer,
2856 VkQueryPool queryPool,
2857 uint32_t slot);
2858
2859 void VKAPI vkCmdResetQueryPool(
2860 VkCmdBuffer cmdBuffer,
2861 VkQueryPool queryPool,
2862 uint32_t startQuery,
2863 uint32_t queryCount);
2864
2865 void VKAPI vkCmdWriteTimestamp(
2866 VkCmdBuffer cmdBuffer,
2867 VkTimestampType timestampType,
2868 VkBuffer destBuffer,
2869 VkDeviceSize destOffset);
2870
2871 void VKAPI vkCmdCopyQueryPoolResults(
2872 VkCmdBuffer cmdBuffer,
2873 VkQueryPool queryPool,
2874 uint32_t startQuery,
2875 uint32_t queryCount,
2876 VkBuffer destBuffer,
2877 VkDeviceSize destOffset,
2878 VkDeviceSize destStride,
2879 VkQueryResultFlags flags);
2880
2881 void VKAPI vkCmdPushConstants(
2882 VkCmdBuffer cmdBuffer,
2883 VkPipelineLayout layout,
2884 VkShaderStageFlags stageFlags,
2885 uint32_t start,
2886 uint32_t length,
2887 const void* values);
2888
2889 void VKAPI vkCmdBeginRenderPass(
2890 VkCmdBuffer cmdBuffer,
2891 const VkRenderPassBeginInfo* pRenderPassBegin,
2892 VkRenderPassContents contents);
2893
2894 void VKAPI vkCmdNextSubpass(
2895 VkCmdBuffer cmdBuffer,
2896 VkRenderPassContents contents);
2897
2898 void VKAPI vkCmdEndRenderPass(
2899 VkCmdBuffer cmdBuffer);
2900
2901 void VKAPI vkCmdExecuteCommands(
2902 VkCmdBuffer cmdBuffer,
2903 uint32_t cmdBuffersCount,
2904 const VkCmdBuffer* pCmdBuffers);
2905 #endif
2906
2907 #ifdef __cplusplus
2908 }
2909 #endif
2910
2911 #endif