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