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