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