Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 89e99e6dd74c1f407c2f2cb1aac2ad4ca3d45ff2 / . / include / vulkan.h
blob: b78a56cd957433d3e70db5c4def3297679a4664c [file] [log] [blame]
Courtney Goeltzenleuchter89e99e62015-04-08 18:04:29 -0600[diff] [blame^]1//
2// File: vulkan.h
3//
4/*
5** Copyright (c) 2014 The Khronos Group Inc.
6**
7** Permission is hereby granted, free of charge, to any person obtaining a
8** copy of this software and/or associated documentation files (the
9** "Materials"), to deal in the Materials without restriction, including
10** without limitation the rights to use, copy, modify, merge, publish,
11** distribute, sublicense, and/or sell copies of the Materials, and to
12** permit persons to whom the Materials are furnished to do so, subject to
13** the following conditions:
14**
15** The above copyright notice and this permission notice shall be included
16** in all copies or substantial portions of the Materials.
17**
18** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
22** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
25*/
26
27#ifndef __VULKAN_H__
28#define __VULKAN_H__
29
30#define VK_MAKE_VERSION(major, minor, patch) \
31 ((major << 22) | (minor << 12) | patch)
32
33#include "vkPlatform.h"
34
35// VK API version supported by this file
36#define VK_API_VERSION VK_MAKE_VERSION(0, 67, 0)
37
38#ifdef __cplusplus
39extern "C"
40{
41#endif // __cplusplus
42
43/*
44***************************************************************************************************
45* Core VK API
46***************************************************************************************************
47*/
48
49#ifdef __cplusplus
50 #define VK_DEFINE_HANDLE(_obj) struct _obj##_T {char _dummy;}; typedef _obj##_T* _obj;
51 #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj;
52#else // __cplusplus
53 #define VK_DEFINE_HANDLE(_obj) typedef void* _obj;
54 #define VK_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj;
55#endif // __cplusplus
56
57VK_DEFINE_HANDLE(VK_INSTANCE)
58VK_DEFINE_HANDLE(VK_PHYSICAL_GPU)
59VK_DEFINE_HANDLE(VK_BASE_OBJECT)
60VK_DEFINE_SUBCLASS_HANDLE(VK_DEVICE, VK_BASE_OBJECT)
61VK_DEFINE_SUBCLASS_HANDLE(VK_QUEUE, VK_BASE_OBJECT)
62VK_DEFINE_SUBCLASS_HANDLE(VK_GPU_MEMORY, VK_BASE_OBJECT)
63VK_DEFINE_SUBCLASS_HANDLE(VK_OBJECT, VK_BASE_OBJECT)
64VK_DEFINE_SUBCLASS_HANDLE(VK_BUFFER, VK_OBJECT)
65VK_DEFINE_SUBCLASS_HANDLE(VK_BUFFER_VIEW, VK_OBJECT)
66VK_DEFINE_SUBCLASS_HANDLE(VK_IMAGE, VK_OBJECT)
67VK_DEFINE_SUBCLASS_HANDLE(VK_IMAGE_VIEW, VK_OBJECT)
68VK_DEFINE_SUBCLASS_HANDLE(VK_COLOR_ATTACHMENT_VIEW, VK_OBJECT)
69VK_DEFINE_SUBCLASS_HANDLE(VK_DEPTH_STENCIL_VIEW, VK_OBJECT)
70VK_DEFINE_SUBCLASS_HANDLE(VK_SHADER, VK_OBJECT)
71VK_DEFINE_SUBCLASS_HANDLE(VK_PIPELINE, VK_OBJECT)
72VK_DEFINE_SUBCLASS_HANDLE(VK_SAMPLER, VK_OBJECT)
73VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET, VK_OBJECT)
74VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET_LAYOUT, VK_OBJECT)
75VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_SET_LAYOUT_CHAIN, VK_OBJECT)
76VK_DEFINE_SUBCLASS_HANDLE(VK_DESCRIPTOR_POOL, VK_OBJECT)
77VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_STATE_OBJECT, VK_OBJECT)
78VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_VP_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT)
79VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_RS_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT)
80VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_CB_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT)
81VK_DEFINE_SUBCLASS_HANDLE(VK_DYNAMIC_DS_STATE_OBJECT, VK_DYNAMIC_STATE_OBJECT)
82VK_DEFINE_SUBCLASS_HANDLE(VK_CMD_BUFFER, VK_OBJECT)
83VK_DEFINE_SUBCLASS_HANDLE(VK_FENCE, VK_OBJECT)
84VK_DEFINE_SUBCLASS_HANDLE(VK_SEMAPHORE, VK_OBJECT)
85VK_DEFINE_SUBCLASS_HANDLE(VK_EVENT, VK_OBJECT)
86VK_DEFINE_SUBCLASS_HANDLE(VK_QUERY_POOL, VK_OBJECT)
87VK_DEFINE_SUBCLASS_HANDLE(VK_FRAMEBUFFER, VK_OBJECT)
88VK_DEFINE_SUBCLASS_HANDLE(VK_RENDER_PASS, VK_OBJECT)
89
90#define VK_MAX_PHYSICAL_GPUS 16
91#define VK_MAX_PHYSICAL_GPU_NAME 256
92
93#define VK_LOD_CLAMP_NONE MAX_FLOAT
94#define VK_LAST_MIP_OR_SLICE 0xffffffff
95
96#define VK_TRUE 1
97#define VK_FALSE 0
98
99#define VK_NULL_HANDLE 0
100
101// This macro defines INT_MAX in enumerations to force compilers to use 32 bits
102// to represent them. This may or may not be necessary on some compilers. The
103// option to compile it out may allow compilers that warn about missing enumerants
104// in switch statements to be silenced.
105#define VK_MAX_ENUM(T) T##_MAX_ENUM = 0x7FFFFFFF
106
107// ------------------------------------------------------------------------------------------------
108// Enumerations
109
110
111typedef enum _VK_MEMORY_PRIORITY
112{
113 VK_MEMORY_PRIORITY_UNUSED = 0x0,
114 VK_MEMORY_PRIORITY_VERY_LOW = 0x1,
115 VK_MEMORY_PRIORITY_LOW = 0x2,
116 VK_MEMORY_PRIORITY_NORMAL = 0x3,
117 VK_MEMORY_PRIORITY_HIGH = 0x4,
118 VK_MEMORY_PRIORITY_VERY_HIGH = 0x5,
119
120 VK_MEMORY_PRIORITY_BEGIN_RANGE = VK_MEMORY_PRIORITY_UNUSED,
121 VK_MEMORY_PRIORITY_END_RANGE = VK_MEMORY_PRIORITY_VERY_HIGH,
122 VK_NUM_MEMORY_PRIORITY = (VK_MEMORY_PRIORITY_END_RANGE - VK_MEMORY_PRIORITY_BEGIN_RANGE + 1),
123 VK_MAX_ENUM(_VK_MEMORY_PRIORITY)
124} VK_MEMORY_PRIORITY;
125
126typedef enum _VK_IMAGE_LAYOUT
127{
128 VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000, // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
129 VK_IMAGE_LAYOUT_GENERAL = 0x00000001, // General layout when image can be used for any kind of access
130 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002, // Optimal layout when image is only used for color attachment read/write
131 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, // Optimal layout when image is only used for depth/stencil attachment read/write
132 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, // Optimal layout when image is used for read only depth/stencil attachment and shader access
133 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, // Optimal layout when image is used for read only shader access
134 VK_IMAGE_LAYOUT_CLEAR_OPTIMAL = 0x00000006, // Optimal layout when image is used only for clear operations
135 VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000007, // Optimal layout when image is used only as source of transfer operations
136 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000008, // Optimal layout when image is used only as destination of transfer operations
137
138 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
139 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
140 VK_NUM_IMAGE_LAYOUT = (VK_IMAGE_LAYOUT_END_RANGE - VK_IMAGE_LAYOUT_BEGIN_RANGE + 1),
141 VK_MAX_ENUM(_VK_IMAGE_LAYOUT)
142} VK_IMAGE_LAYOUT;
143
144typedef enum _VK_PIPE_EVENT
145{
146 VK_PIPE_EVENT_TOP_OF_PIPE = 0x00000001, // Set event before the GPU starts processing subsequent command
147 VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002, // Set event when all pending vertex processing is complete
148 VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 0x00000003, // Set event when all pending fragment shader executions are complete, within each fragment location
149 VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 0x00000004, // Set event when all pending fragment shader executions are complete
150 VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 0x00000005, // Set event when all pending graphics operations are complete
151 VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 0x00000006, // Set event when all pending compute operations are complete
152 VK_PIPE_EVENT_TRANSFER_COMPLETE = 0x00000007, // Set event when all pending transfer operations are complete
153 VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE = 0x00000008, // Set event when all pending GPU work is complete
154
155 VK_PIPE_EVENT_BEGIN_RANGE = VK_PIPE_EVENT_TOP_OF_PIPE,
156 VK_PIPE_EVENT_END_RANGE = VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE,
157 VK_NUM_PIPE_EVENT = (VK_PIPE_EVENT_END_RANGE - VK_PIPE_EVENT_BEGIN_RANGE + 1),
158 VK_MAX_ENUM(_VK_PIPE_EVENT)
159} VK_PIPE_EVENT;
160
161typedef enum _VK_WAIT_EVENT
162{
163 VK_WAIT_EVENT_TOP_OF_PIPE = 0x00000001, // Wait event before the GPU starts processing subsequent commands
164 VK_WAIT_EVENT_BEFORE_RASTERIZATION = 0x00000002, // Wait event before rasterizing subsequent primitives
165
166 VK_WAIT_EVENT_BEGIN_RANGE = VK_WAIT_EVENT_TOP_OF_PIPE,
167 VK_WAIT_EVENT_END_RANGE = VK_WAIT_EVENT_BEFORE_RASTERIZATION,
168 VK_NUM_WAIT_EVENT = (VK_WAIT_EVENT_END_RANGE - VK_WAIT_EVENT_BEGIN_RANGE + 1),
169 VK_MAX_ENUM(_VK_WAIT_EVENT)
170} VK_WAIT_EVENT;
171
172typedef enum _VK_MEMORY_OUTPUT_FLAGS
173{
174 VK_MEMORY_OUTPUT_CPU_WRITE_BIT = 0x00000001, // Controls output coherency of CPU writes
175 VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, // Controls output coherency of generic shader writes
176 VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, // Controls output coherency of color attachment writes
177 VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, // Controls output coherency of depth/stencil attachment writes
178 VK_MEMORY_OUTPUT_COPY_BIT = 0x00000010, // Controls output coherency of copy operations
179 VK_MAX_ENUM(_VK_MEMORY_OUTPUT_FLAGS)
180} VK_MEMORY_OUTPUT_FLAGS;
181
182typedef enum _VK_MEMORY_INPUT_FLAGS
183{
184 VK_MEMORY_INPUT_CPU_READ_BIT = 0x00000001, // Controls input coherency of CPU reads
185 VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, // Controls input coherency of indirect command reads
186 VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, // Controls input coherency of index fetches
187 VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, // Controls input coherency of vertex attribute fetches
188 VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, // Controls input coherency of uniform buffer reads
189 VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, // Controls input coherency of generic shader reads
190 VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, // Controls input coherency of color attachment reads
191 VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, // Controls input coherency of depth/stencil attachment reads
192 VK_MEMORY_INPUT_COPY_BIT = 0x00000100, // Controls input coherency of copy operations
193 VK_MAX_ENUM(_VK_MEMORY_INPUT_FLAGS)
194} VK_MEMORY_INPUT_FLAGS;
195
196typedef enum _VK_ATTACHMENT_LOAD_OP
197{
198 VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000,
199 VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001,
200 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002,
201
202 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
203 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
204 VK_NUM_ATTACHMENT_LOAD_OP = (VK_ATTACHMENT_LOAD_OP_END_RANGE - VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE + 1),
205 VK_MAX_ENUM(_VK_ATTACHMENT_LOAD_OP)
206} VK_ATTACHMENT_LOAD_OP;
207
208typedef enum _VK_ATTACHMENT_STORE_OP
209{
210 VK_ATTACHMENT_STORE_OP_STORE = 0x00000000,
211 VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001,
212 VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000002,
213
214 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
215 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
216 VK_NUM_ATTACHMENT_STORE_OP = (VK_ATTACHMENT_STORE_OP_END_RANGE - VK_ATTACHMENT_STORE_OP_BEGIN_RANGE + 1),
217 VK_MAX_ENUM(_VK_ATTACHMENT_STORE_OP)
218} VK_ATTACHMENT_STORE_OP;
219
220typedef enum _VK_IMAGE_TYPE
221{
222 VK_IMAGE_1D = 0x00000000,
223 VK_IMAGE_2D = 0x00000001,
224 VK_IMAGE_3D = 0x00000002,
225
226 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_1D,
227 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_3D,
228 VK_NUM_IMAGE_TYPE = (VK_IMAGE_TYPE_END_RANGE - VK_IMAGE_TYPE_BEGIN_RANGE + 1),
229 VK_MAX_ENUM(_VK_IMAGE_TYPE)
230} VK_IMAGE_TYPE;
231
232typedef enum _VK_IMAGE_TILING
233{
234 VK_LINEAR_TILING = 0x00000000,
235 VK_OPTIMAL_TILING = 0x00000001,
236
237 VK_IMAGE_TILING_BEGIN_RANGE = VK_LINEAR_TILING,
238 VK_IMAGE_TILING_END_RANGE = VK_OPTIMAL_TILING,
239 VK_NUM_IMAGE_TILING = (VK_IMAGE_TILING_END_RANGE - VK_IMAGE_TILING_BEGIN_RANGE + 1),
240 VK_MAX_ENUM(_VK_IMAGE_TILING)
241} VK_IMAGE_TILING;
242
243typedef enum _VK_IMAGE_VIEW_TYPE
244{
245 VK_IMAGE_VIEW_1D = 0x00000000,
246 VK_IMAGE_VIEW_2D = 0x00000001,
247 VK_IMAGE_VIEW_3D = 0x00000002,
248 VK_IMAGE_VIEW_CUBE = 0x00000003,
249
250 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_1D,
251 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_CUBE,
252 VK_NUM_IMAGE_VIEW_TYPE = (VK_IMAGE_VIEW_TYPE_END_RANGE - VK_IMAGE_VIEW_TYPE_BEGIN_RANGE + 1),
253 VK_MAX_ENUM(_VK_IMAGE_VIEW_TYPE)
254} VK_IMAGE_VIEW_TYPE;
255
256typedef enum _VK_IMAGE_ASPECT
257{
258 VK_IMAGE_ASPECT_COLOR = 0x00000000,
259 VK_IMAGE_ASPECT_DEPTH = 0x00000001,
260 VK_IMAGE_ASPECT_STENCIL = 0x00000002,
261
262 VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR,
263 VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_STENCIL,
264 VK_NUM_IMAGE_ASPECT = (VK_IMAGE_ASPECT_END_RANGE - VK_IMAGE_ASPECT_BEGIN_RANGE + 1),
265 VK_MAX_ENUM(_VK_IMAGE_ASPECT)
266} VK_IMAGE_ASPECT;
267
268typedef enum _VK_CHANNEL_SWIZZLE
269{
270 VK_CHANNEL_SWIZZLE_ZERO = 0x00000000,
271 VK_CHANNEL_SWIZZLE_ONE = 0x00000001,
272 VK_CHANNEL_SWIZZLE_R = 0x00000002,
273 VK_CHANNEL_SWIZZLE_G = 0x00000003,
274 VK_CHANNEL_SWIZZLE_B = 0x00000004,
275 VK_CHANNEL_SWIZZLE_A = 0x00000005,
276
277 VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO,
278 VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A,
279 VK_NUM_CHANNEL_SWIZZLE = (VK_CHANNEL_SWIZZLE_END_RANGE - VK_CHANNEL_SWIZZLE_BEGIN_RANGE + 1),
280 VK_MAX_ENUM(_VK_CHANNEL_SWIZZLE)
281} VK_CHANNEL_SWIZZLE;
282
283typedef enum _VK_DESCRIPTOR_TYPE
284{
285 VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000,
286 VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE = 0x00000001,
287 VK_DESCRIPTOR_TYPE_TEXTURE = 0x00000002,
288 VK_DESCRIPTOR_TYPE_TEXTURE_BUFFER = 0x00000003,
289 VK_DESCRIPTOR_TYPE_IMAGE = 0x00000004,
290 VK_DESCRIPTOR_TYPE_IMAGE_BUFFER = 0x00000005,
291 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006,
292 VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER = 0x00000007,
293 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008,
294 VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC = 0x00000009,
295
296 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
297 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC,
298 VK_NUM_DESCRIPTOR_TYPE = (VK_DESCRIPTOR_TYPE_END_RANGE - VK_DESCRIPTOR_TYPE_BEGIN_RANGE + 1),
299 VK_MAX_ENUM(_VK_DESCRIPTOR_TYPE)
300} VK_DESCRIPTOR_TYPE;
301
302typedef enum _VK_DESCRIPTOR_POOL_USAGE
303{
304 VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000,
305 VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001,
306
307 VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
308 VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC,
309 VK_NUM_DESCRIPTOR_POOL_USAGE = (VK_DESCRIPTOR_POOL_USAGE_END_RANGE - VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE + 1),
310 VK_MAX_ENUM(_VK_DESCRIPTOR_POOL_USAGE)
311} VK_DESCRIPTOR_POOL_USAGE;
312
313typedef enum _VK_DESCRIPTOR_UPDATE_MODE
314{
315 VK_DESCRIPTOR_UDPATE_MODE_COPY = 0x00000000,
316 VK_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001,
317
318 VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE = VK_DESCRIPTOR_UDPATE_MODE_COPY,
319 VK_DESCRIPTOR_UPDATE_MODE_END_RANGE = VK_DESCRIPTOR_UPDATE_MODE_FASTEST,
320 VK_NUM_DESCRIPTOR_UPDATE_MODE = (VK_DESCRIPTOR_UPDATE_MODE_END_RANGE - VK_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE + 1),
321 VK_MAX_ENUM(_VK_DESCRIPTOR_UPDATE_MODE)
322} VK_DESCRIPTOR_UPDATE_MODE;
323
324typedef enum _VK_DESCRIPTOR_SET_USAGE
325{
326 VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000,
327 VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001,
328
329 VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT,
330 VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC,
331 VK_NUM_DESCRIPTOR_SET_USAGE = (VK_DESCRIPTOR_SET_USAGE_END_RANGE - VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE + 1),
332 VK_MAX_ENUM(_VK_DESCRIPTOR_SET_USAGE)
333} VK_DESCRIPTOR_SET_USAGE;
334
335typedef enum _VK_QUERY_TYPE
336{
337 VK_QUERY_OCCLUSION = 0x00000000,
338 VK_QUERY_PIPELINE_STATISTICS = 0x00000001,
339
340 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_OCCLUSION,
341 VK_QUERY_TYPE_END_RANGE = VK_QUERY_PIPELINE_STATISTICS,
342 VK_NUM_QUERY_TYPE = (VK_QUERY_TYPE_END_RANGE - VK_QUERY_TYPE_BEGIN_RANGE + 1),
343 VK_MAX_ENUM(_VK_QUERY_TYPE)
344} VK_QUERY_TYPE;
345
346typedef enum _VK_TIMESTAMP_TYPE
347{
348 VK_TIMESTAMP_TOP = 0x00000000,
349 VK_TIMESTAMP_BOTTOM = 0x00000001,
350
351 VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TOP,
352 VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_BOTTOM,
353 VK_NUM_TIMESTAMP_TYPE = (VK_TIMESTAMP_TYPE_END_RANGE - VK_TIMESTAMP_TYPE_BEGIN_RANGE + 1),
354 VK_MAX_ENUM(_VK_TIMESTEAMP_TYPE)
355} VK_TIMESTAMP_TYPE;
356
357typedef enum _VK_BORDER_COLOR_TYPE
358{
359 VK_BORDER_COLOR_OPAQUE_WHITE = 0x00000000,
360 VK_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001,
361 VK_BORDER_COLOR_OPAQUE_BLACK = 0x00000002,
362
363 VK_BORDER_COLOR_TYPE_BEGIN_RANGE = VK_BORDER_COLOR_OPAQUE_WHITE,
364 VK_BORDER_COLOR_TYPE_END_RANGE = VK_BORDER_COLOR_OPAQUE_BLACK,
365 VK_NUM_BORDER_COLOR_TYPE = (VK_BORDER_COLOR_TYPE_END_RANGE - VK_BORDER_COLOR_TYPE_BEGIN_RANGE + 1),
366 VK_MAX_ENUM(_VK_BORDER_COLOR_TYPE)
367} VK_BORDER_COLOR_TYPE;
368
369typedef enum _VK_PIPELINE_BIND_POINT
370{
371 VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000,
372 VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001,
373
374 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
375 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
376 VK_NUM_PIPELINE_BIND_POINT = (VK_PIPELINE_BIND_POINT_END_RANGE - VK_PIPELINE_BIND_POINT_BEGIN_RANGE + 1),
377 VK_MAX_ENUM(_VK_PIPELINE_BIND_POINT)
378} VK_PIPELINE_BIND_POINT;
379
380typedef enum _VK_STATE_BIND_POINT
381{
382 VK_STATE_BIND_VIEWPORT = 0x00000000,
383 VK_STATE_BIND_RASTER = 0x00000001,
384 VK_STATE_BIND_COLOR_BLEND = 0x00000002,
385 VK_STATE_BIND_DEPTH_STENCIL = 0x00000003,
386
387 VK_STATE_BIND_POINT_BEGIN_RANGE = VK_STATE_BIND_VIEWPORT,
388 VK_STATE_BIND_POINT_END_RANGE = VK_STATE_BIND_DEPTH_STENCIL,
389 VK_NUM_STATE_BIND_POINT = (VK_STATE_BIND_POINT_END_RANGE - VK_STATE_BIND_POINT_BEGIN_RANGE + 1),
390 VK_MAX_ENUM(_VK_STATE_BIND_POINT)
391} VK_STATE_BIND_POINT;
392
393typedef enum _VK_PRIMITIVE_TOPOLOGY
394{
395 VK_TOPOLOGY_POINT_LIST = 0x00000000,
396 VK_TOPOLOGY_LINE_LIST = 0x00000001,
397 VK_TOPOLOGY_LINE_STRIP = 0x00000002,
398 VK_TOPOLOGY_TRIANGLE_LIST = 0x00000003,
399 VK_TOPOLOGY_TRIANGLE_STRIP = 0x00000004,
400 VK_TOPOLOGY_TRIANGLE_FAN = 0x00000005,
401 VK_TOPOLOGY_LINE_LIST_ADJ = 0x00000006,
402 VK_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007,
403 VK_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008,
404 VK_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009,
405 VK_TOPOLOGY_PATCH = 0x0000000a,
406
407 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_TOPOLOGY_POINT_LIST,
408 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_TOPOLOGY_PATCH,
409 VK_NUM_PRIMITIVE_TOPOLOGY = (VK_PRIMITIVE_TOPOLOGY_END_RANGE - VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE + 1),
410 VK_MAX_ENUM(_VK_PRIMITIVE_TOPOLOGY)
411} VK_PRIMITIVE_TOPOLOGY;
412
413typedef enum _VK_INDEX_TYPE
414{
415 VK_INDEX_8 = 0x00000000,
416 VK_INDEX_16 = 0x00000001,
417 VK_INDEX_32 = 0x00000002,
418
419 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_8,
420 VK_INDEX_TYPE_END_RANGE = VK_INDEX_32,
421 VK_NUM_INDEX_TYPE = (VK_INDEX_TYPE_END_RANGE - VK_INDEX_TYPE_BEGIN_RANGE + 1),
422 VK_MAX_ENUM(_VK_INDEX_TYPE)
423} VK_INDEX_TYPE;
424
425typedef enum _VK_TEX_FILTER
426{
427 VK_TEX_FILTER_NEAREST = 0,
428 VK_TEX_FILTER_LINEAR = 1,
429
430 VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST,
431 VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR,
432 VK_NUM_TEX_FILTER = (VK_TEX_FILTER_END_RANGE - VK_TEX_FILTER_BEGIN_RANGE + 1),
433 VK_MAX_ENUM(_VK_TEX_FILTER)
434} VK_TEX_FILTER;
435
436typedef enum _VK_TEX_MIPMAP_MODE
437{
438 VK_TEX_MIPMAP_BASE = 0, // Always choose base level
439 VK_TEX_MIPMAP_NEAREST = 1, // Choose nearest mip level
440 VK_TEX_MIPMAP_LINEAR = 2, // Linear filter between mip levels
441
442 VK_TEX_MIPMAP_BEGIN_RANGE = VK_TEX_MIPMAP_BASE,
443 VK_TEX_MIPMAP_END_RANGE = VK_TEX_MIPMAP_LINEAR,
444 VK_NUM_TEX_MIPMAP = (VK_TEX_MIPMAP_END_RANGE - VK_TEX_MIPMAP_BEGIN_RANGE + 1),
445 VK_MAX_ENUM(_VK_TEX_MIPMAP_MODE)
446} VK_TEX_MIPMAP_MODE;
447
448typedef enum _VK_TEX_ADDRESS
449{
450 VK_TEX_ADDRESS_WRAP = 0x00000000,
451 VK_TEX_ADDRESS_MIRROR = 0x00000001,
452 VK_TEX_ADDRESS_CLAMP = 0x00000002,
453 VK_TEX_ADDRESS_MIRROR_ONCE = 0x00000003,
454 VK_TEX_ADDRESS_CLAMP_BORDER = 0x00000004,
455
456 VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP,
457 VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER,
458 VK_NUM_TEX_ADDRESS = (VK_TEX_ADDRESS_END_RANGE - VK_TEX_ADDRESS_BEGIN_RANGE + 1),
459 VK_MAX_ENUM(_VK_TEX_ADDRESS)
460} VK_TEX_ADDRESS;
461
462typedef enum _VK_COMPARE_FUNC
463{
464 VK_COMPARE_NEVER = 0x00000000,
465 VK_COMPARE_LESS = 0x00000001,
466 VK_COMPARE_EQUAL = 0x00000002,
467 VK_COMPARE_LESS_EQUAL = 0x00000003,
468 VK_COMPARE_GREATER = 0x00000004,
469 VK_COMPARE_NOT_EQUAL = 0x00000005,
470 VK_COMPARE_GREATER_EQUAL = 0x00000006,
471 VK_COMPARE_ALWAYS = 0x00000007,
472
473 VK_COMPARE_FUNC_BEGIN_RANGE = VK_COMPARE_NEVER,
474 VK_COMPARE_FUNC_END_RANGE = VK_COMPARE_ALWAYS,
475 VK_NUM_COMPARE_FUNC = (VK_COMPARE_FUNC_END_RANGE - VK_COMPARE_FUNC_BEGIN_RANGE + 1),
476 VK_MAX_ENUM(_VK_COMPARE_FUNC)
477} VK_COMPARE_FUNC;
478
479typedef enum _VK_FILL_MODE
480{
481 VK_FILL_POINTS = 0x00000000,
482 VK_FILL_WIREFRAME = 0x00000001,
483 VK_FILL_SOLID = 0x00000002,
484
485 VK_FILL_MODE_BEGIN_RANGE = VK_FILL_POINTS,
486 VK_FILL_MODE_END_RANGE = VK_FILL_SOLID,
487 VK_NUM_FILL_MODE = (VK_FILL_MODE_END_RANGE - VK_FILL_MODE_BEGIN_RANGE + 1),
488 VK_MAX_ENUM(_VK_FILL_MODE)
489} VK_FILL_MODE;
490
491typedef enum _VK_CULL_MODE
492{
493 VK_CULL_NONE = 0x00000000,
494 VK_CULL_FRONT = 0x00000001,
495 VK_CULL_BACK = 0x00000002,
496 VK_CULL_FRONT_AND_BACK = 0x00000003,
497
498 VK_CULL_MODE_BEGIN_RANGE = VK_CULL_NONE,
499 VK_CULL_MODE_END_RANGE = VK_CULL_FRONT_AND_BACK,
500 VK_NUM_CULL_MODE = (VK_CULL_MODE_END_RANGE - VK_CULL_MODE_BEGIN_RANGE + 1),
501 VK_MAX_ENUM(_VK_CULL_MODE)
502} VK_CULL_MODE;
503
504typedef enum _VK_FACE_ORIENTATION
505{
506 VK_FRONT_FACE_CCW = 0x00000000,
507 VK_FRONT_FACE_CW = 0x00000001,
508
509 VK_FACE_ORIENTATION_BEGIN_RANGE = VK_FRONT_FACE_CCW,
510 VK_FACE_ORIENTATION_END_RANGE = VK_FRONT_FACE_CW,
511 VK_NUM_FACE_ORIENTATION = (VK_FACE_ORIENTATION_END_RANGE - VK_FACE_ORIENTATION_BEGIN_RANGE + 1),
512 VK_MAX_ENUM(_VK_FACE_ORIENTATION)
513} VK_FACE_ORIENTATION;
514
515typedef enum _VK_PROVOKING_VERTEX_CONVENTION
516{
517 VK_PROVOKING_VERTEX_FIRST = 0x00000000,
518 VK_PROVOKING_VERTEX_LAST = 0x00000001,
519
520 VK_PROVOKING_VERTEX_BEGIN_RANGE = VK_PROVOKING_VERTEX_FIRST,
521 VK_PROVOKING_VERTEX_END_RANGE = VK_PROVOKING_VERTEX_LAST,
522 VK_NUM_PROVOKING_VERTEX_CONVENTION = (VK_PROVOKING_VERTEX_END_RANGE - VK_PROVOKING_VERTEX_BEGIN_RANGE + 1),
523 VK_MAX_ENUM(_VK_PROVOKING_VERTEX_CONVENTION)
524} VK_PROVOKING_VERTEX_CONVENTION;
525
526typedef enum _VK_COORDINATE_ORIGIN
527{
528 VK_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000,
529 VK_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001,
530
531 VK_COORDINATE_ORIGIN_BEGIN_RANGE = VK_COORDINATE_ORIGIN_UPPER_LEFT,
532 VK_COORDINATE_ORIGIN_END_RANGE = VK_COORDINATE_ORIGIN_LOWER_LEFT,
533 VK_NUM_COORDINATE_ORIGIN = (VK_COORDINATE_ORIGIN_END_RANGE - VK_COORDINATE_ORIGIN_END_RANGE + 1),
534 VK_MAX_ENUM(_VK_COORDINATE_ORIGIN)
535} VK_COORDINATE_ORIGIN;
536
537typedef enum _VK_DEPTH_MODE
538{
539 VK_DEPTH_MODE_ZERO_TO_ONE = 0x00000000,
540 VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001,
541
542 VK_DEPTH_MODE_BEGIN_RANGE = VK_DEPTH_MODE_ZERO_TO_ONE,
543 VK_DEPTH_MODE_END_RANGE = VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE,
544 VK_NUM_DEPTH_MODE = (VK_DEPTH_MODE_END_RANGE - VK_DEPTH_MODE_BEGIN_RANGE + 1),
545 VK_MAX_ENUM(_VK_DEPTH_MODE)
546} VK_DEPTH_MODE;
547
548typedef enum _VK_BLEND
549{
550 VK_BLEND_ZERO = 0x00000000,
551 VK_BLEND_ONE = 0x00000001,
552 VK_BLEND_SRC_COLOR = 0x00000002,
553 VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
554 VK_BLEND_DEST_COLOR = 0x00000004,
555 VK_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005,
556 VK_BLEND_SRC_ALPHA = 0x00000006,
557 VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007,
558 VK_BLEND_DEST_ALPHA = 0x00000008,
559 VK_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009,
560 VK_BLEND_CONSTANT_COLOR = 0x0000000a,
561 VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
562 VK_BLEND_CONSTANT_ALPHA = 0x0000000c,
563 VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
564 VK_BLEND_SRC_ALPHA_SATURATE = 0x0000000e,
565 VK_BLEND_SRC1_COLOR = 0x0000000f,
566 VK_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010,
567 VK_BLEND_SRC1_ALPHA = 0x00000011,
568 VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012,
569
570 VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO,
571 VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA,
572 VK_NUM_BLEND = (VK_BLEND_END_RANGE - VK_BLEND_BEGIN_RANGE + 1),
573 VK_MAX_ENUM(_VK_BLEND)
574} VK_BLEND;
575
576typedef enum _VK_BLEND_FUNC
577{
578 VK_BLEND_FUNC_ADD = 0x00000000,
579 VK_BLEND_FUNC_SUBTRACT = 0x00000001,
580 VK_BLEND_FUNC_REVERSE_SUBTRACT = 0x00000002,
581 VK_BLEND_FUNC_MIN = 0x00000003,
582 VK_BLEND_FUNC_MAX = 0x00000004,
583
584 VK_BLEND_FUNC_BEGIN_RANGE = VK_BLEND_FUNC_ADD,
585 VK_BLEND_FUNC_END_RANGE = VK_BLEND_FUNC_MAX,
586 VK_NUM_BLEND_FUNC = (VK_BLEND_FUNC_END_RANGE - VK_BLEND_FUNC_BEGIN_RANGE + 1),
587 VK_MAX_ENUM(_VK_BLEND_FUNC)
588} VK_BLEND_FUNC;
589
590typedef enum _VK_STENCIL_OP
591{
592 VK_STENCIL_OP_KEEP = 0x00000000,
593 VK_STENCIL_OP_ZERO = 0x00000001,
594 VK_STENCIL_OP_REPLACE = 0x00000002,
595 VK_STENCIL_OP_INC_CLAMP = 0x00000003,
596 VK_STENCIL_OP_DEC_CLAMP = 0x00000004,
597 VK_STENCIL_OP_INVERT = 0x00000005,
598 VK_STENCIL_OP_INC_WRAP = 0x00000006,
599 VK_STENCIL_OP_DEC_WRAP = 0x00000007,
600
601 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
602 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP,
603 VK_NUM_STENCIL_OP = (VK_STENCIL_OP_END_RANGE - VK_STENCIL_OP_BEGIN_RANGE + 1),
604 VK_MAX_ENUM(_VK_STENCIL_OP)
605} VK_STENCIL_OP;
606
607typedef enum _VK_LOGIC_OP
608{
609 VK_LOGIC_OP_COPY = 0x00000000,
610 VK_LOGIC_OP_CLEAR = 0x00000001,
611 VK_LOGIC_OP_AND = 0x00000002,
612 VK_LOGIC_OP_AND_REVERSE = 0x00000003,
613 VK_LOGIC_OP_AND_INVERTED = 0x00000004,
614 VK_LOGIC_OP_NOOP = 0x00000005,
615 VK_LOGIC_OP_XOR = 0x00000006,
616 VK_LOGIC_OP_OR = 0x00000007,
617 VK_LOGIC_OP_NOR = 0x00000008,
618 VK_LOGIC_OP_EQUIV = 0x00000009,
619 VK_LOGIC_OP_INVERT = 0x0000000a,
620 VK_LOGIC_OP_OR_REVERSE = 0x0000000b,
621 VK_LOGIC_OP_COPY_INVERTED = 0x0000000c,
622 VK_LOGIC_OP_OR_INVERTED = 0x0000000d,
623 VK_LOGIC_OP_NAND = 0x0000000e,
624 VK_LOGIC_OP_SET = 0x0000000f,
625
626 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_COPY,
627 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
628 VK_NUM_LOGIC_OP = (VK_LOGIC_OP_END_RANGE - VK_LOGIC_OP_BEGIN_RANGE + 1),
629 VK_MAX_ENUM(_VK_LOGIC_OP)
630} VK_LOGIC_OP;
631
632typedef enum _VK_SYSTEM_ALLOC_TYPE
633{
634 VK_SYSTEM_ALLOC_API_OBJECT = 0x00000000,
635 VK_SYSTEM_ALLOC_INTERNAL = 0x00000001,
636 VK_SYSTEM_ALLOC_INTERNAL_TEMP = 0x00000002,
637 VK_SYSTEM_ALLOC_INTERNAL_SHADER = 0x00000003,
638 VK_SYSTEM_ALLOC_DEBUG = 0x00000004,
639
640 VK_SYSTEM_ALLOC_BEGIN_RANGE = VK_SYSTEM_ALLOC_API_OBJECT,
641 VK_SYSTEM_ALLOC_END_RANGE = VK_SYSTEM_ALLOC_DEBUG,
642 VK_NUM_SYSTEM_ALLOC_TYPE = (VK_SYSTEM_ALLOC_END_RANGE - VK_SYSTEM_ALLOC_BEGIN_RANGE + 1),
643 VK_MAX_ENUM(_VK_SYSTEM_ALLOC_TYPE)
644} VK_SYSTEM_ALLOC_TYPE;
645
646typedef enum _VK_PHYSICAL_GPU_TYPE
647{
648 VK_GPU_TYPE_OTHER = 0x00000000,
649 VK_GPU_TYPE_INTEGRATED = 0x00000001,
650 VK_GPU_TYPE_DISCRETE = 0x00000002,
651 VK_GPU_TYPE_VIRTUAL = 0x00000003,
652
653 VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE = VK_GPU_TYPE_OTHER,
654 VK_PHYSICAL_GPU_TYPE_END_RANGE = VK_GPU_TYPE_VIRTUAL,
655 VK_NUM_PHYSICAL_GPU_TYPE = (VK_PHYSICAL_GPU_TYPE_END_RANGE - VK_PHYSICAL_GPU_TYPE_BEGIN_RANGE + 1),
656 VK_MAX_ENUM(_VK_PHYSICAL_GPU_TYPE)
657} VK_PHYSICAL_GPU_TYPE;
658
659typedef enum _VK_PHYSICAL_GPU_INFO_TYPE
660{
661 // Info type for vkGetGpuInfo()
662 VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES = 0x00000000,
663 VK_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE = 0x00000001,
664 VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES = 0x00000002,
665 VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES = 0x00000003,
666
667 VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE = VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES,
668 VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE = VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES,
669 VK_NUM_INFO_TYPE_PHYSICAL_GPU = (VK_INFO_TYPE_PHYSICAL_GPU_END_RANGE - VK_INFO_TYPE_PHYSICAL_GPU_BEGIN_RANGE + 1),
670 VK_MAX_ENUM(_VK_PHYSICAL_GPU_INFO_TYPE)
671} VK_PHYSICAL_GPU_INFO_TYPE;
672
673typedef enum _VK_FORMAT_INFO_TYPE
674{
675 // Info type for vkGetFormatInfo()
676 VK_INFO_TYPE_FORMAT_PROPERTIES = 0x00000000,
677
678 VK_INFO_TYPE_FORMAT_BEGIN_RANGE = VK_INFO_TYPE_FORMAT_PROPERTIES,
679 VK_INFO_TYPE_FORMAT_END_RANGE = VK_INFO_TYPE_FORMAT_PROPERTIES,
680 VK_NUM_INFO_TYPE_FORMAT = (VK_INFO_TYPE_FORMAT_END_RANGE - VK_INFO_TYPE_FORMAT_BEGIN_RANGE + 1),
681 VK_MAX_ENUM(_VK_FORMAT_INFO_TYPE)
682} VK_FORMAT_INFO_TYPE;
683
684typedef enum _VK_SUBRESOURCE_INFO_TYPE
685{
686 // Info type for vkGetImageSubresourceInfo()
687 VK_INFO_TYPE_SUBRESOURCE_LAYOUT = 0x00000000,
688
689 VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE = VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
690 VK_INFO_TYPE_SUBRESOURCE_END_RANGE = VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
691 VK_NUM_INFO_TYPE_SUBRESOURCE = (VK_INFO_TYPE_SUBRESOURCE_END_RANGE - VK_INFO_TYPE_SUBRESOURCE_BEGIN_RANGE + 1),
692 VK_MAX_ENUM(_VK_SUBRESOURCE_INFO_TYPE)
693} VK_SUBRESOURCE_INFO_TYPE;
694
695typedef enum _VK_OBJECT_INFO_TYPE
696{
697 // Info type for vkGetObjectInfo()
698 VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000,
699 VK_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001,
700 VK_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS = 0x00000002,
701 VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS = 0x00000003,
702
703 VK_INFO_TYPE_BEGIN_RANGE = VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
704 VK_INFO_TYPE_END_RANGE = VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
705 VK_NUM_INFO_TYPE = (VK_INFO_TYPE_END_RANGE - VK_INFO_TYPE_BEGIN_RANGE + 1),
706 VK_MAX_ENUM(_VK_OBJECT_INFO_TYPE)
707} VK_OBJECT_INFO_TYPE;
708
709typedef enum _VK_VALIDATION_LEVEL
710{
711 VK_VALIDATION_LEVEL_0 = 0x00000000,
712 VK_VALIDATION_LEVEL_1 = 0x00000001,
713 VK_VALIDATION_LEVEL_2 = 0x00000002,
714 VK_VALIDATION_LEVEL_3 = 0x00000003,
715 VK_VALIDATION_LEVEL_4 = 0x00000004,
716
717 VK_VALIDATION_LEVEL_BEGIN_RANGE = VK_VALIDATION_LEVEL_0,
718 VK_VALIDATION_LEVEL_END_RANGE = VK_VALIDATION_LEVEL_4,
719 VK_NUM_VALIDATION_LEVEL = (VK_VALIDATION_LEVEL_END_RANGE - VK_VALIDATION_LEVEL_BEGIN_RANGE + 1),
720
721 VK_MAX_ENUM(_VK_VALIDATION_LEVEL)
722} VK_VALIDATION_LEVEL;
723
724// ------------------------------------------------------------------------------------------------
725// Error and return codes
726
727typedef enum _VK_RESULT
728{
729 // Return codes for successful operation execution (>= 0)
730 VK_SUCCESS = 0x0000000,
731 VK_UNSUPPORTED = 0x0000001,
732 VK_NOT_READY = 0x0000002,
733 VK_TIMEOUT = 0x0000003,
734 VK_EVENT_SET = 0x0000004,
735 VK_EVENT_RESET = 0x0000005,
736
737 // Error codes (negative values)
738 VK_ERROR_UNKNOWN = -(0x00000001),
739 VK_ERROR_UNAVAILABLE = -(0x00000002),
740 VK_ERROR_INITIALIZATION_FAILED = -(0x00000003),
741 VK_ERROR_OUT_OF_MEMORY = -(0x00000004),
742 VK_ERROR_OUT_OF_GPU_MEMORY = -(0x00000005),
743 VK_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006),
744 VK_ERROR_DEVICE_LOST = -(0x00000007),
745 VK_ERROR_INVALID_POINTER = -(0x00000008),
746 VK_ERROR_INVALID_VALUE = -(0x00000009),
747 VK_ERROR_INVALID_HANDLE = -(0x0000000A),
748 VK_ERROR_INVALID_ORDINAL = -(0x0000000B),
749 VK_ERROR_INVALID_MEMORY_SIZE = -(0x0000000C),
750 VK_ERROR_INVALID_EXTENSION = -(0x0000000D),
751 VK_ERROR_INVALID_FLAGS = -(0x0000000E),
752 VK_ERROR_INVALID_ALIGNMENT = -(0x0000000F),
753 VK_ERROR_INVALID_FORMAT = -(0x00000010),
754 VK_ERROR_INVALID_IMAGE = -(0x00000011),
755 VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -(0x00000012),
756 VK_ERROR_INVALID_QUEUE_TYPE = -(0x00000013),
757 VK_ERROR_INVALID_OBJECT_TYPE = -(0x00000014),
758 VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -(0x00000015),
759 VK_ERROR_BAD_SHADER_CODE = -(0x00000016),
760 VK_ERROR_BAD_PIPELINE_DATA = -(0x00000017),
761 VK_ERROR_TOO_MANY_MEMORY_REFERENCES = -(0x00000018),
762 VK_ERROR_NOT_MAPPABLE = -(0x00000019),
763 VK_ERROR_MEMORY_MAP_FAILED = -(0x0000001A),
764 VK_ERROR_MEMORY_UNMAP_FAILED = -(0x0000001B),
765 VK_ERROR_INCOMPATIBLE_DEVICE = -(0x0000001C),
766 VK_ERROR_INCOMPATIBLE_DRIVER = -(0x0000001D),
767 VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -(0x0000001E),
768 VK_ERROR_BUILDING_COMMAND_BUFFER = -(0x0000001F),
769 VK_ERROR_MEMORY_NOT_BOUND = -(0x00000020),
770 VK_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021),
771 VK_ERROR_NOT_SHAREABLE = -(0x00000022),
772 VK_MAX_ENUM(_VK_RESULT_CODE)
773} VK_RESULT;
774
775// ------------------------------------------------------------------------------------------------
776// VK format definitions
777
778typedef enum _VK_VERTEX_INPUT_STEP_RATE
779{
780 VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0,
781 VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1,
782 VK_VERTEX_INPUT_STEP_RATE_DRAW = 0x2, //Optional
783
784 VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX,
785 VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_DRAW,
786 VK_NUM_VERTEX_INPUT_STEP_RATE = (VK_VERTEX_INPUT_STEP_RATE_END_RANGE - VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE + 1),
787 VK_MAX_ENUM(_VK_VERTEX_INPUT_STEP_RATE)
788} VK_VERTEX_INPUT_STEP_RATE;
789
790typedef enum _VK_FORMAT
791{
792 VK_FMT_UNDEFINED = 0x00000000,
793 VK_FMT_R4G4_UNORM = 0x00000001,
794 VK_FMT_R4G4_USCALED = 0x00000002,
795 VK_FMT_R4G4B4A4_UNORM = 0x00000003,
796 VK_FMT_R4G4B4A4_USCALED = 0x00000004,
797 VK_FMT_R5G6B5_UNORM = 0x00000005,
798 VK_FMT_R5G6B5_USCALED = 0x00000006,
799 VK_FMT_R5G5B5A1_UNORM = 0x00000007,
800 VK_FMT_R5G5B5A1_USCALED = 0x00000008,
801 VK_FMT_R8_UNORM = 0x00000009,
802 VK_FMT_R8_SNORM = 0x0000000A,
803 VK_FMT_R8_USCALED = 0x0000000B,
804 VK_FMT_R8_SSCALED = 0x0000000C,
805 VK_FMT_R8_UINT = 0x0000000D,
806 VK_FMT_R8_SINT = 0x0000000E,
807 VK_FMT_R8_SRGB = 0x0000000F,
808 VK_FMT_R8G8_UNORM = 0x00000010,
809 VK_FMT_R8G8_SNORM = 0x00000011,
810 VK_FMT_R8G8_USCALED = 0x00000012,
811 VK_FMT_R8G8_SSCALED = 0x00000013,
812 VK_FMT_R8G8_UINT = 0x00000014,
813 VK_FMT_R8G8_SINT = 0x00000015,
814 VK_FMT_R8G8_SRGB = 0x00000016,
815 VK_FMT_R8G8B8_UNORM = 0x00000017,
816 VK_FMT_R8G8B8_SNORM = 0x00000018,
817 VK_FMT_R8G8B8_USCALED = 0x00000019,
818 VK_FMT_R8G8B8_SSCALED = 0x0000001A,
819 VK_FMT_R8G8B8_UINT = 0x0000001B,
820 VK_FMT_R8G8B8_SINT = 0x0000001C,
821 VK_FMT_R8G8B8_SRGB = 0x0000001D,
822 VK_FMT_R8G8B8A8_UNORM = 0x0000001E,
823 VK_FMT_R8G8B8A8_SNORM = 0x0000001F,
824 VK_FMT_R8G8B8A8_USCALED = 0x00000020,
825 VK_FMT_R8G8B8A8_SSCALED = 0x00000021,
826 VK_FMT_R8G8B8A8_UINT = 0x00000022,
827 VK_FMT_R8G8B8A8_SINT = 0x00000023,
828 VK_FMT_R8G8B8A8_SRGB = 0x00000024,
829 VK_FMT_R10G10B10A2_UNORM = 0x00000025,
830 VK_FMT_R10G10B10A2_SNORM = 0x00000026,
831 VK_FMT_R10G10B10A2_USCALED = 0x00000027,
832 VK_FMT_R10G10B10A2_SSCALED = 0x00000028,
833 VK_FMT_R10G10B10A2_UINT = 0x00000029,
834 VK_FMT_R10G10B10A2_SINT = 0x0000002A,
835 VK_FMT_R16_UNORM = 0x0000002B,
836 VK_FMT_R16_SNORM = 0x0000002C,
837 VK_FMT_R16_USCALED = 0x0000002D,
838 VK_FMT_R16_SSCALED = 0x0000002E,
839 VK_FMT_R16_UINT = 0x0000002F,
840 VK_FMT_R16_SINT = 0x00000030,
841 VK_FMT_R16_SFLOAT = 0x00000031,
842 VK_FMT_R16G16_UNORM = 0x00000032,
843 VK_FMT_R16G16_SNORM = 0x00000033,
844 VK_FMT_R16G16_USCALED = 0x00000034,
845 VK_FMT_R16G16_SSCALED = 0x00000035,
846 VK_FMT_R16G16_UINT = 0x00000036,
847 VK_FMT_R16G16_SINT = 0x00000037,
848 VK_FMT_R16G16_SFLOAT = 0x00000038,
849 VK_FMT_R16G16B16_UNORM = 0x00000039,
850 VK_FMT_R16G16B16_SNORM = 0x0000003A,
851 VK_FMT_R16G16B16_USCALED = 0x0000003B,
852 VK_FMT_R16G16B16_SSCALED = 0x0000003C,
853 VK_FMT_R16G16B16_UINT = 0x0000003D,
854 VK_FMT_R16G16B16_SINT = 0x0000003E,
855 VK_FMT_R16G16B16_SFLOAT = 0x0000003F,
856 VK_FMT_R16G16B16A16_UNORM = 0x00000040,
857 VK_FMT_R16G16B16A16_SNORM = 0x00000041,
858 VK_FMT_R16G16B16A16_USCALED = 0x00000042,
859 VK_FMT_R16G16B16A16_SSCALED = 0x00000043,
860 VK_FMT_R16G16B16A16_UINT = 0x00000044,
861 VK_FMT_R16G16B16A16_SINT = 0x00000045,
862 VK_FMT_R16G16B16A16_SFLOAT = 0x00000046,
863 VK_FMT_R32_UINT = 0x00000047,
864 VK_FMT_R32_SINT = 0x00000048,
865 VK_FMT_R32_SFLOAT = 0x00000049,
866 VK_FMT_R32G32_UINT = 0x0000004A,
867 VK_FMT_R32G32_SINT = 0x0000004B,
868 VK_FMT_R32G32_SFLOAT = 0x0000004C,
869 VK_FMT_R32G32B32_UINT = 0x0000004D,
870 VK_FMT_R32G32B32_SINT = 0x0000004E,
871 VK_FMT_R32G32B32_SFLOAT = 0x0000004F,
872 VK_FMT_R32G32B32A32_UINT = 0x00000050,
873 VK_FMT_R32G32B32A32_SINT = 0x00000051,
874 VK_FMT_R32G32B32A32_SFLOAT = 0x00000052,
875 VK_FMT_R64_SFLOAT = 0x00000053,
876 VK_FMT_R64G64_SFLOAT = 0x00000054,
877 VK_FMT_R64G64B64_SFLOAT = 0x00000055,
878 VK_FMT_R64G64B64A64_SFLOAT = 0x00000056,
879 VK_FMT_R11G11B10_UFLOAT = 0x00000057,
880 VK_FMT_R9G9B9E5_UFLOAT = 0x00000058,
881 VK_FMT_D16_UNORM = 0x00000059,
882 VK_FMT_D24_UNORM = 0x0000005A,
883 VK_FMT_D32_SFLOAT = 0x0000005B,
884 VK_FMT_S8_UINT = 0x0000005C,
885 VK_FMT_D16_UNORM_S8_UINT = 0x0000005D,
886 VK_FMT_D24_UNORM_S8_UINT = 0x0000005E,
887 VK_FMT_D32_SFLOAT_S8_UINT = 0x0000005F,
888 VK_FMT_BC1_RGB_UNORM = 0x00000060,
889 VK_FMT_BC1_RGB_SRGB = 0x00000061,
890 VK_FMT_BC1_RGBA_UNORM = 0x00000062,
891 VK_FMT_BC1_RGBA_SRGB = 0x00000063,
892 VK_FMT_BC2_UNORM = 0x00000064,
893 VK_FMT_BC2_SRGB = 0x00000065,
894 VK_FMT_BC3_UNORM = 0x00000066,
895 VK_FMT_BC3_SRGB = 0x00000067,
896 VK_FMT_BC4_UNORM = 0x00000068,
897 VK_FMT_BC4_SNORM = 0x00000069,
898 VK_FMT_BC5_UNORM = 0x0000006A,
899 VK_FMT_BC5_SNORM = 0x0000006B,
900 VK_FMT_BC6H_UFLOAT = 0x0000006C,
901 VK_FMT_BC6H_SFLOAT = 0x0000006D,
902 VK_FMT_BC7_UNORM = 0x0000006E,
903 VK_FMT_BC7_SRGB = 0x0000006F,
904 VK_FMT_ETC2_R8G8B8_UNORM = 0x00000070,
905 VK_FMT_ETC2_R8G8B8_SRGB = 0x00000071,
906 VK_FMT_ETC2_R8G8B8A1_UNORM = 0x00000072,
907 VK_FMT_ETC2_R8G8B8A1_SRGB = 0x00000073,
908 VK_FMT_ETC2_R8G8B8A8_UNORM = 0x00000074,
909 VK_FMT_ETC2_R8G8B8A8_SRGB = 0x00000075,
910 VK_FMT_EAC_R11_UNORM = 0x00000076,
911 VK_FMT_EAC_R11_SNORM = 0x00000077,
912 VK_FMT_EAC_R11G11_UNORM = 0x00000078,
913 VK_FMT_EAC_R11G11_SNORM = 0x00000079,
914 VK_FMT_ASTC_4x4_UNORM = 0x0000007A,
915 VK_FMT_ASTC_4x4_SRGB = 0x0000007B,
916 VK_FMT_ASTC_5x4_UNORM = 0x0000007C,
917 VK_FMT_ASTC_5x4_SRGB = 0x0000007D,
918 VK_FMT_ASTC_5x5_UNORM = 0x0000007E,
919 VK_FMT_ASTC_5x5_SRGB = 0x0000007F,
920 VK_FMT_ASTC_6x5_UNORM = 0x00000080,
921 VK_FMT_ASTC_6x5_SRGB = 0x00000081,
922 VK_FMT_ASTC_6x6_UNORM = 0x00000082,
923 VK_FMT_ASTC_6x6_SRGB = 0x00000083,
924 VK_FMT_ASTC_8x5_UNORM = 0x00000084,
925 VK_FMT_ASTC_8x5_SRGB = 0x00000085,
926 VK_FMT_ASTC_8x6_UNORM = 0x00000086,
927 VK_FMT_ASTC_8x6_SRGB = 0x00000087,
928 VK_FMT_ASTC_8x8_UNORM = 0x00000088,
929 VK_FMT_ASTC_8x8_SRGB = 0x00000089,
930 VK_FMT_ASTC_10x5_UNORM = 0x0000008A,
931 VK_FMT_ASTC_10x5_SRGB = 0x0000008B,
932 VK_FMT_ASTC_10x6_UNORM = 0x0000008C,
933 VK_FMT_ASTC_10x6_SRGB = 0x0000008D,
934 VK_FMT_ASTC_10x8_UNORM = 0x0000008E,
935 VK_FMT_ASTC_10x8_SRGB = 0x0000008F,
936 VK_FMT_ASTC_10x10_UNORM = 0x00000090,
937 VK_FMT_ASTC_10x10_SRGB = 0x00000091,
938 VK_FMT_ASTC_12x10_UNORM = 0x00000092,
939 VK_FMT_ASTC_12x10_SRGB = 0x00000093,
940 VK_FMT_ASTC_12x12_UNORM = 0x00000094,
941 VK_FMT_ASTC_12x12_SRGB = 0x00000095,
942 VK_FMT_B4G4R4A4_UNORM = 0x00000096,
943 VK_FMT_B5G5R5A1_UNORM = 0x00000097,
944 VK_FMT_B5G6R5_UNORM = 0x00000098,
945 VK_FMT_B5G6R5_USCALED = 0x00000099,
946 VK_FMT_B8G8R8_UNORM = 0x0000009A,
947 VK_FMT_B8G8R8_SNORM = 0x0000009B,
948 VK_FMT_B8G8R8_USCALED = 0x0000009C,
949 VK_FMT_B8G8R8_SSCALED = 0x0000009D,
950 VK_FMT_B8G8R8_UINT = 0x0000009E,
951 VK_FMT_B8G8R8_SINT = 0x0000009F,
952 VK_FMT_B8G8R8_SRGB = 0x000000A0,
953 VK_FMT_B8G8R8A8_UNORM = 0x000000A1,
954 VK_FMT_B8G8R8A8_SNORM = 0x000000A2,
955 VK_FMT_B8G8R8A8_USCALED = 0x000000A3,
956 VK_FMT_B8G8R8A8_SSCALED = 0x000000A4,
957 VK_FMT_B8G8R8A8_UINT = 0x000000A5,
958 VK_FMT_B8G8R8A8_SINT = 0x000000A6,
959 VK_FMT_B8G8R8A8_SRGB = 0x000000A7,
960 VK_FMT_B10G10R10A2_UNORM = 0x000000A8,
961 VK_FMT_B10G10R10A2_SNORM = 0x000000A9,
962 VK_FMT_B10G10R10A2_USCALED = 0x000000AA,
963 VK_FMT_B10G10R10A2_SSCALED = 0x000000AB,
964 VK_FMT_B10G10R10A2_UINT = 0x000000AC,
965 VK_FMT_B10G10R10A2_SINT = 0x000000AD,
966
967 VK_FMT_BEGIN_RANGE = VK_FMT_UNDEFINED,
968 VK_FMT_END_RANGE = VK_FMT_B10G10R10A2_SINT,
969 VK_NUM_FMT = (VK_FMT_END_RANGE - VK_FMT_BEGIN_RANGE + 1),
970 VK_MAX_ENUM(_VK_FORMAT)
971} VK_FORMAT;
972
973// Shader stage enumerant
974typedef enum _VK_PIPELINE_SHADER_STAGE
975{
976 VK_SHADER_STAGE_VERTEX = 0,
977 VK_SHADER_STAGE_TESS_CONTROL = 1,
978 VK_SHADER_STAGE_TESS_EVALUATION = 2,
979 VK_SHADER_STAGE_GEOMETRY = 3,
980 VK_SHADER_STAGE_FRAGMENT = 4,
981 VK_SHADER_STAGE_COMPUTE = 5,
982
983 VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX,
984 VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE,
985 VK_NUM_SHADER_STAGE = (VK_SHADER_STAGE_END_RANGE - VK_SHADER_STAGE_BEGIN_RANGE + 1),
986 VK_MAX_ENUM(_VK_PIPELINE_SHADER_STAGE)
987} VK_PIPELINE_SHADER_STAGE;
988
989typedef enum _VK_SHADER_STAGE_FLAGS
990{
991 VK_SHADER_STAGE_FLAGS_VERTEX_BIT = 0x00000001,
992 VK_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT = 0x00000002,
993 VK_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT = 0x00000004,
994 VK_SHADER_STAGE_FLAGS_GEOMETRY_BIT = 0x00000008,
995 VK_SHADER_STAGE_FLAGS_FRAGMENT_BIT = 0x00000010,
996 VK_SHADER_STAGE_FLAGS_COMPUTE_BIT = 0x00000020,
997
998 VK_SHADER_STAGE_FLAGS_ALL = 0x7FFFFFFF,
999 VK_MAX_ENUM(_VK_SHADER_STAGE_FLAGS)
1000} VK_SHADER_STAGE_FLAGS;
1001
1002// Structure type enumerant
1003typedef enum _VK_STRUCTURE_TYPE
1004{
1005 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
1006 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
1007 VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
1008 VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 4,
1009 VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 5,
1010 VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 6,
1011 VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 7,
1012 VK_STRUCTURE_TYPE_EVENT_WAIT_INFO = 8,
1013 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 9,
1014 VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 10,
1015 VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 11,
1016 VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 12,
1017 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13,
1018 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14,
1019 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 15,
1020 VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 16,
1021 VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 17,
1022 VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 18,
1023 VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 19,
1024 VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20,
1025 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21,
1026 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22,
1027 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 23,
1028 VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 24,
1029 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25,
1030 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26,
1031 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27,
1032 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 28,
1033 VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 29,
1034 VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 30,
1035 VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 31,
1036 VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 32,
1037 VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 33,
1038 VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 34,
1039 VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 35,
1040 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 36,
1041 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 37,
1042 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 38,
1043 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 39,
1044 VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 40,
1045 VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 41,
1046 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 42,
1047 VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 43,
1048 VK_STRUCTURE_TYPE_PIPELINE_BARRIER = 44,
1049 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
1050 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 46,
1051 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 47,
1052 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 48,
1053 VK_STRUCTURE_TYPE_UPDATE_SAMPLERS = 49,
1054 VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 50,
1055 VK_STRUCTURE_TYPE_UPDATE_IMAGES = 51,
1056 VK_STRUCTURE_TYPE_UPDATE_BUFFERS = 52,
1057 VK_STRUCTURE_TYPE_UPDATE_AS_COPY = 53,
1058 VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO = 54,
1059 VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO = 55,
1060 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 56,
1061 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
1062 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
1063 VK_NUM_STRUCTURE_TYPE = (VK_STRUCTURE_TYPE_END_RANGE - VK_STRUCTURE_TYPE_BEGIN_RANGE + 1),
1064 VK_MAX_ENUM(_VK_STRUCTURE_TYPE)
1065} VK_STRUCTURE_TYPE;
1066
1067// ------------------------------------------------------------------------------------------------
1068// Flags
1069
1070// Device creation flags
1071typedef enum _VK_DEVICE_CREATE_FLAGS
1072{
1073 VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
1074 VK_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002,
1075 VK_MAX_ENUM(_VK_DEVICE_CREATE_FLAGS)
1076} VK_DEVICE_CREATE_FLAGS;
1077
1078// Queue capabilities
1079typedef enum _VK_QUEUE_FLAGS
1080{
1081 VK_QUEUE_GRAPHICS_BIT = 0x00000001, // Queue supports graphics operations
1082 VK_QUEUE_COMPUTE_BIT = 0x00000002, // Queue supports compute operations
1083 VK_QUEUE_DMA_BIT = 0x00000004, // Queue supports DMA operations
1084 VK_QUEUE_EXTENDED_BIT = 0x40000000, // Extended queue
1085 VK_MAX_ENUM(_VK_QUEUE_FLAGS)
1086} VK_QUEUE_FLAGS;
1087
1088// memory properties passed into vkAllocMemory().
1089typedef enum _VK_MEMORY_PROPERTY_FLAGS
1090{
1091 VK_MEMORY_PROPERTY_GPU_ONLY = 0x00000000, // If not set, then allocate memory on device (GPU)
1092 VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT = 0x00000001,
1093 VK_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT = 0x00000002,
1094 VK_MEMORY_PROPERTY_CPU_UNCACHED_BIT = 0x00000004,
1095 VK_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT = 0x00000008,
1096 VK_MEMORY_PROPERTY_PREFER_CPU_LOCAL = 0x00000010, // all else being equal, prefer CPU access
1097 VK_MEMORY_PROPERTY_SHAREABLE_BIT = 0x00000020,
1098 VK_MAX_ENUM(_VK_MEMORY_PROPERTY_FLAGS)
1099} VK_MEMORY_PROPERTY_FLAGS;
1100
1101typedef enum _VK_MEMORY_TYPE
1102{
1103 VK_MEMORY_TYPE_OTHER = 0x00000000, // device memory that is not any of the others
1104 VK_MEMORY_TYPE_BUFFER = 0x00000001, // memory for buffers and associated information
1105 VK_MEMORY_TYPE_IMAGE = 0x00000002, // memory for images and associated information
1106
1107 VK_MEMORY_TYPE_BEGIN_RANGE = VK_MEMORY_TYPE_OTHER,
1108 VK_MEMORY_TYPE_END_RANGE = VK_MEMORY_TYPE_IMAGE,
1109 VK_NUM_MEMORY_TYPE = (VK_MEMORY_TYPE_END_RANGE - VK_MEMORY_TYPE_BEGIN_RANGE + 1),
1110 VK_MAX_ENUM(_VK_MEMORY_TYPE)
1111} VK_MEMORY_TYPE;
1112
1113// Buffer and buffer allocation usage flags
1114typedef enum _VK_BUFFER_USAGE_FLAGS
1115{
1116 VK_BUFFER_USAGE_GENERAL = 0x00000000, // no special usage
1117 VK_BUFFER_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // Shader read (e.g. TBO, image buffer, UBO, SSBO)
1118 VK_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002, // Shader write (e.g. image buffer, SSBO)
1119 VK_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT = 0x00000004, // Shader atomic operations (e.g. image buffer, SSBO)
1120 VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000008, // used as a source for copies
1121 VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000010, // used as a destination for copies
1122 VK_BUFFER_USAGE_UNIFORM_READ_BIT = 0x00000020, // Uniform read (UBO)
1123 VK_BUFFER_USAGE_INDEX_FETCH_BIT = 0x00000040, // Fixed function index fetch (index buffer)
1124 VK_BUFFER_USAGE_VERTEX_FETCH_BIT = 0x00000080, // Fixed function vertex fetch (VBO)
1125 VK_BUFFER_USAGE_SHADER_STORAGE_BIT = 0x00000100, // Shader storage buffer (SSBO)
1126 VK_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT = 0x00000200, // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
1127 VK_BUFFER_USAGE_TEXTURE_BUFFER_BIT = 0x00000400, // texture buffer (TBO)
1128 VK_BUFFER_USAGE_IMAGE_BUFFER_BIT = 0x00000800, // image buffer (load/store)
1129 VK_MAX_ENUM(_VK_BUFFER_USAGE_FLAGS)
1130} VK_BUFFER_USAGE_FLAGS;
1131
1132// Buffer flags
1133typedef enum _VK_BUFFER_CREATE_FLAGS
1134{
1135 VK_BUFFER_CREATE_SHAREABLE_BIT = 0x00000001,
1136 VK_BUFFER_CREATE_SPARSE_BIT = 0x00000002,
1137 VK_MAX_ENUM(_VK_BUFFER_CREATE_FLAGS)
1138} VK_BUFFER_CREATE_FLAGS;
1139
1140typedef enum _VK_BUFFER_VIEW_TYPE
1141{
1142 VK_BUFFER_VIEW_RAW = 0x00000000, // Raw buffer without special structure (e.g. UBO, SSBO, indirect and parameter buffers)
1143 VK_BUFFER_VIEW_TYPED = 0x00000001, // Typed buffer, format and channels are used (TBO, image buffer)
1144
1145 VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_RAW,
1146 VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPED,
1147 VK_NUM_BUFFER_VIEW_TYPE = (VK_BUFFER_VIEW_TYPE_END_RANGE - VK_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1),
1148 VK_MAX_ENUM(_VK_BUFFER_VIEW_TYPE)
1149} VK_BUFFER_VIEW_TYPE;
1150
1151
1152// Images memory allocations can be used for resources of a given format class.
1153typedef enum _VK_IMAGE_FORMAT_CLASS
1154{
1155 VK_IMAGE_FORMAT_CLASS_128_BITS = 1, // color formats
1156 VK_IMAGE_FORMAT_CLASS_96_BITS = 2,
1157 VK_IMAGE_FORMAT_CLASS_64_BITS = 3,
1158 VK_IMAGE_FORMAT_CLASS_48_BITS = 4,
1159 VK_IMAGE_FORMAT_CLASS_32_BITS = 5,
1160 VK_IMAGE_FORMAT_CLASS_24_BITS = 6,
1161 VK_IMAGE_FORMAT_CLASS_16_BITS = 7,
1162 VK_IMAGE_FORMAT_CLASS_8_BITS = 8,
1163 VK_IMAGE_FORMAT_CLASS_128_BIT_BLOCK = 9, // 128-bit block compressed formats
1164 VK_IMAGE_FORMAT_CLASS_64_BIT_BLOCK = 10, // 64-bit block compressed formats
1165 VK_IMAGE_FORMAT_CLASS_D32 = 11, // D32_SFLOAT
1166 VK_IMAGE_FORMAT_CLASS_D24 = 12, // D24_UNORM
1167 VK_IMAGE_FORMAT_CLASS_D16 = 13, // D16_UNORM
1168 VK_IMAGE_FORMAT_CLASS_S8 = 14, // S8_UINT
1169 VK_IMAGE_FORMAT_CLASS_D32S8 = 15, // D32_SFLOAT_S8_UINT
1170 VK_IMAGE_FORMAT_CLASS_D24S8 = 16, // D24_UNORM_S8_UINT
1171 VK_IMAGE_FORMAT_CLASS_D16S8 = 17, // D16_UNORM_S8_UINT
1172 VK_IMAGE_FORMAT_CLASS_LINEAR = 18, // used for pitch-linear (transparent) textures
1173
1174 VK_IMAGE_FORMAT_CLASS_BEGIN_RANGE = VK_IMAGE_FORMAT_CLASS_128_BITS,
1175 VK_IMAGE_FORMAT_CLASS_END_RANGE = VK_IMAGE_FORMAT_CLASS_LINEAR,
1176 VK_NUM_IMAGE_FORMAT_CLASS = (VK_IMAGE_FORMAT_CLASS_END_RANGE - VK_IMAGE_FORMAT_CLASS_BEGIN_RANGE + 1),
1177 VK_MAX_ENUM(_VK_IMAGE_FORMAT_CLASS)
1178} VK_IMAGE_FORMAT_CLASS;
1179
1180// Image and image allocation usage flags
1181typedef enum _VK_IMAGE_USAGE_FLAGS
1182{
1183 VK_IMAGE_USAGE_GENERAL = 0x00000000, // no special usage
1184 VK_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // shader read (e.g. texture, image)
1185 VK_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002, // shader write (e.g. image)
1186 VK_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT = 0x00000004, // shader atomic operations (e.g. image)
1187 VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000008, // used as a source for copies
1188 VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000010, // used as a destination for copies
1189 VK_IMAGE_USAGE_TEXTURE_BIT = 0x00000020, // opaque texture (2d, 3d, etc.)
1190 VK_IMAGE_USAGE_IMAGE_BIT = 0x00000040, // opaque image (2d, 3d, etc.)
1191 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000080, // framebuffer color attachment
1192 VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000100, // framebuffer depth/stencil
1193 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000200, // image data not needed outside of rendering.
1194 VK_MAX_ENUM(_VK_IMAGE_USAGE_FLAGS)
1195} VK_IMAGE_USAGE_FLAGS;
1196
1197// Image flags
1198typedef enum _VK_IMAGE_CREATE_FLAGS
1199{
1200 VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001,
1201 VK_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002,
1202 VK_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004,
1203 VK_IMAGE_CREATE_SPARSE_BIT = 0x00000008,
1204 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, // Allows image views to have different format than the base image
1205 VK_MAX_ENUM(_VK_IMAGE_CREATE_FLAGS)
1206} VK_IMAGE_CREATE_FLAGS;
1207
1208// Depth-stencil view creation flags
1209typedef enum _VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS
1210{
1211 VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
1212 VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
1213 VK_MAX_ENUM(_VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS)
1214} VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS;
1215
1216// Pipeline creation flags
1217typedef enum _VK_PIPELINE_CREATE_FLAGS
1218{
1219 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
1220 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
1221 VK_MAX_ENUM(_VK_PIPELINE_CREATE_FLAGS)
1222} VK_PIPELINE_CREATE_FLAGS;
1223
1224// Fence creation flags
1225typedef enum _VK_FENCE_CREATE_FLAGS
1226{
1227 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
1228 VK_MAX_ENUM(_VK_FENCE_CREATE_FLAGS)
1229} VK_FENCE_CREATE_FLAGS;
1230
1231// Semaphore creation flags
1232typedef enum _VK_SEMAPHORE_CREATE_FLAGS
1233{
1234 VK_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001,
1235 VK_MAX_ENUM(_VK_SEMAPHORE_CREATE_FLAGS)
1236} VK_SEMAPHORE_CREATE_FLAGS;
1237
1238// Format capability flags
1239typedef enum _VK_FORMAT_FEATURE_FLAGS
1240{
1241 VK_FORMAT_IMAGE_SHADER_READ_BIT = 0x00000001,
1242 VK_FORMAT_IMAGE_SHADER_WRITE_BIT = 0x00000002,
1243 VK_FORMAT_IMAGE_COPY_BIT = 0x00000004,
1244 VK_FORMAT_MEMORY_SHADER_ACCESS_BIT = 0x00000008,
1245 VK_FORMAT_COLOR_ATTACHMENT_WRITE_BIT = 0x00000010,
1246 VK_FORMAT_COLOR_ATTACHMENT_BLEND_BIT = 0x00000020,
1247 VK_FORMAT_DEPTH_ATTACHMENT_BIT = 0x00000040,
1248 VK_FORMAT_STENCIL_ATTACHMENT_BIT = 0x00000080,
1249 VK_FORMAT_MSAA_ATTACHMENT_BIT = 0x00000100,
1250 VK_FORMAT_CONVERSION_BIT = 0x00000200,
1251 VK_MAX_ENUM(_VK_FORMAT_FEATURE_FLAGS)
1252} VK_FORMAT_FEATURE_FLAGS;
1253
1254// Query flags
1255typedef enum _VK_QUERY_CONTROL_FLAGS
1256{
1257 VK_QUERY_IMPRECISE_DATA_BIT = 0x00000001,
1258 VK_MAX_ENUM(_VK_QUERY_CONTROL_FLAGS)
1259} VK_QUERY_CONTROL_FLAGS;
1260
1261// GPU compatibility flags
1262typedef enum _VK_GPU_COMPATIBILITY_FLAGS
1263{
1264 VK_GPU_COMPAT_ASIC_FEATURES_BIT = 0x00000001,
1265 VK_GPU_COMPAT_IQ_MATCH_BIT = 0x00000002,
1266 VK_GPU_COMPAT_PEER_TRANSFER_BIT = 0x00000004,
1267 VK_GPU_COMPAT_SHARED_MEMORY_BIT = 0x00000008,
1268 VK_GPU_COMPAT_SHARED_SYNC_BIT = 0x00000010,
1269 VK_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT = 0x00000020,
1270 VK_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT = 0x00000040,
1271 VK_MAX_ENUM(_VK_GPU_COMPATIBILITY_FLAGS)
1272} VK_GPU_COMPATIBILITY_FLAGS;
1273
1274// Command buffer building flags
1275typedef enum _VK_CMD_BUFFER_BUILD_FLAGS
1276{
1277 VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT = 0x00000001,
1278 VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
1279 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
1280 VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
1281 VK_MAX_ENUM(_VK_CMD_BUFFER_BUILD_FLAGS)
1282} VK_CMD_BUFFER_BUILD_FLAGS;
1283
1284// ------------------------------------------------------------------------------------------------
1285// VK structures
1286
1287typedef struct _VK_OFFSET2D
1288{
1289 int32_t x;
1290 int32_t y;
1291} VK_OFFSET2D;
1292
1293typedef struct _VK_OFFSET3D
1294{
1295 int32_t x;
1296 int32_t y;
1297 int32_t z;
1298} VK_OFFSET3D;
1299
1300typedef struct _VK_EXTENT2D
1301{
1302 int32_t width;
1303 int32_t height;
1304} VK_EXTENT2D;
1305
1306typedef struct _VK_EXTENT3D
1307{
1308 int32_t width;
1309 int32_t height;
1310 int32_t depth;
1311} VK_EXTENT3D;
1312
1313typedef struct _VK_VIEWPORT
1314{
1315 float originX;
1316 float originY;
1317 float width;
1318 float height;
1319 float minDepth;
1320 float maxDepth;
1321} VK_VIEWPORT;
1322
1323typedef struct _VK_RECT
1324{
1325 VK_OFFSET2D offset;
1326 VK_EXTENT2D extent;
1327} VK_RECT;
1328
1329typedef struct _VK_CHANNEL_MAPPING
1330{
1331 VK_CHANNEL_SWIZZLE r;
1332 VK_CHANNEL_SWIZZLE g;
1333 VK_CHANNEL_SWIZZLE b;
1334 VK_CHANNEL_SWIZZLE a;
1335} VK_CHANNEL_MAPPING;
1336
1337typedef struct _VK_PHYSICAL_GPU_PROPERTIES
1338{
1339 uint32_t apiVersion;
1340 uint32_t driverVersion;
1341 uint32_t vendorId;
1342 uint32_t deviceId;
1343 VK_PHYSICAL_GPU_TYPE gpuType;
1344 char gpuName[VK_MAX_PHYSICAL_GPU_NAME];
1345 VK_GPU_SIZE maxInlineMemoryUpdateSize;
1346 uint32_t maxBoundDescriptorSets;
1347 uint32_t maxThreadGroupSize;
1348 uint64_t timestampFrequency;
1349 bool32_t multiColorAttachmentClears;
1350 uint32_t maxDescriptorSets; // at least 2?
1351 uint32_t maxViewports; // at least 16?
1352 uint32_t maxColorAttachments; // at least 8?
1353} VK_PHYSICAL_GPU_PROPERTIES;
1354
1355typedef struct _VK_PHYSICAL_GPU_PERFORMANCE
1356{
1357 float maxGpuClock;
1358 float aluPerClock;
1359 float texPerClock;
1360 float primsPerClock;
1361 float pixelsPerClock;
1362} VK_PHYSICAL_GPU_PERFORMANCE;
1363
1364typedef struct _VK_GPU_COMPATIBILITY_INFO
1365{
1366 VK_FLAGS compatibilityFlags; // VK_GPU_COMPATIBILITY_FLAGS
1367} VK_GPU_COMPATIBILITY_INFO;
1368
1369typedef struct _VK_APPLICATION_INFO
1370{
1371 VK_STRUCTURE_TYPE sType; // Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO
1372 const void* pNext; // Next structure in chain
1373 const char* pAppName;
1374 uint32_t appVersion;
1375 const char* pEngineName;
1376 uint32_t engineVersion;
1377 uint32_t apiVersion;
1378} VK_APPLICATION_INFO;
1379
1380typedef void* (VKAPI *VK_ALLOC_FUNCTION)(
1381 void* pUserData,
1382 size_t size,
1383 size_t alignment,
1384 VK_SYSTEM_ALLOC_TYPE allocType);
1385
1386typedef void (VKAPI *VK_FREE_FUNCTION)(
1387 void* pUserData,
1388 void* pMem);
1389
1390typedef struct _VK_ALLOC_CALLBACKS
1391{
1392 void* pUserData;
1393 VK_ALLOC_FUNCTION pfnAlloc;
1394 VK_FREE_FUNCTION pfnFree;
1395} VK_ALLOC_CALLBACKS;
1396
1397typedef struct _VK_DEVICE_QUEUE_CREATE_INFO
1398{
1399 uint32_t queueNodeIndex;
1400 uint32_t queueCount;
1401} VK_DEVICE_QUEUE_CREATE_INFO;
1402
1403typedef struct _VK_DEVICE_CREATE_INFO
1404{
1405 VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
1406 const void* pNext; // Pointer to next structure
1407 uint32_t queueRecordCount;
1408 const VK_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues;
1409 uint32_t extensionCount;
1410 const char*const* ppEnabledExtensionNames;
1411 VK_VALIDATION_LEVEL maxValidationLevel;
1412 VK_FLAGS flags; // VK_DEVICE_CREATE_FLAGS
1413} VK_DEVICE_CREATE_INFO;
1414
1415typedef struct _VK_INSTANCE_CREATE_INFO
1416{
1417 VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
1418 const void* pNext; // Pointer to next structure
1419 const VK_APPLICATION_INFO* pAppInfo;
1420 const VK_ALLOC_CALLBACKS* pAllocCb;
1421 uint32_t extensionCount;
1422 const char*const* ppEnabledExtensionNames; // layer or extension name to be enabled
1423} VK_INSTANCE_CREATE_INFO;
1424
1425// can be added to VK_DEVICE_CREATE_INFO or VK_INSTANCE_CREATE_INFO via pNext
1426typedef struct _VK_LAYER_CREATE_INFO
1427{
1428 VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO
1429 const void* pNext; // Pointer to next structure
1430 uint32_t layerCount;
1431 const char *const* ppActiveLayerNames; // layer name from the layer's vkEnumerateLayers())
1432} VK_LAYER_CREATE_INFO;
1433
1434typedef struct _VK_PHYSICAL_GPU_QUEUE_PROPERTIES
1435{
1436 VK_FLAGS queueFlags; // VK_QUEUE_FLAGS
1437 uint32_t queueCount;
1438 uint32_t maxAtomicCounters;
1439 bool32_t supportsTimestamps;
1440 uint32_t maxMemReferences; // Tells how many memory references can be active for the given queue
1441} VK_PHYSICAL_GPU_QUEUE_PROPERTIES;
1442
1443typedef struct _VK_PHYSICAL_GPU_MEMORY_PROPERTIES
1444{
1445 bool32_t supportsMigration;
1446 bool32_t supportsPinning;
1447} VK_PHYSICAL_GPU_MEMORY_PROPERTIES;
1448
1449typedef struct _VK_MEMORY_ALLOC_INFO
1450{
1451 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
1452 const void* pNext; // Pointer to next structure
1453 VK_GPU_SIZE allocationSize; // Size of memory allocation
1454 VK_FLAGS memProps; // VK_MEMORY_PROPERTY_FLAGS
1455 VK_MEMORY_TYPE memType;
1456 VK_MEMORY_PRIORITY memPriority;
1457} VK_MEMORY_ALLOC_INFO;
1458
1459// This structure is included in the VK_MEMORY_ALLOC_INFO chain
1460// for memory regions allocated for buffer usage.
1461typedef struct _VK_MEMORY_ALLOC_BUFFER_INFO
1462{
1463 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO
1464 const void* pNext; // Pointer to next structure
1465 VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS
1466} VK_MEMORY_ALLOC_BUFFER_INFO;
1467
1468// This structure is included in the VK_MEMORY_ALLOC_INFO chain
1469// for memory regions allocated for image usage.
1470typedef struct _VK_MEMORY_ALLOC_IMAGE_INFO
1471{
1472 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO
1473 const void* pNext; // Pointer to next structure
1474 VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS
1475 VK_IMAGE_FORMAT_CLASS formatClass;
1476 uint32_t samples;
1477} VK_MEMORY_ALLOC_IMAGE_INFO;
1478
1479typedef struct _VK_MEMORY_OPEN_INFO
1480{
1481 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO
1482 const void* pNext; // Pointer to next structure
1483 VK_GPU_MEMORY sharedMem;
1484} VK_MEMORY_OPEN_INFO;
1485
1486typedef struct _VK_PEER_MEMORY_OPEN_INFO
1487{
1488 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO
1489 const void* pNext; // Pointer to next structure
1490 VK_GPU_MEMORY originalMem;
1491} VK_PEER_MEMORY_OPEN_INFO;
1492
1493typedef struct _VK_MEMORY_REQUIREMENTS
1494{
1495 VK_GPU_SIZE size; // Specified in bytes
1496 VK_GPU_SIZE alignment; // Specified in bytes
1497 VK_GPU_SIZE granularity; // Granularity on which vkBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size)
1498 VK_FLAGS memProps; // VK_MEMORY_PROPERTY_FLAGS
1499 VK_MEMORY_TYPE memType;
1500} VK_MEMORY_REQUIREMENTS;
1501
1502typedef struct _VK_BUFFER_MEMORY_REQUIREMENTS
1503{
1504 VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS
1505} VK_BUFFER_MEMORY_REQUIREMENTS;
1506
1507typedef struct _VK_IMAGE_MEMORY_REQUIREMENTS
1508{
1509 VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS
1510 VK_IMAGE_FORMAT_CLASS formatClass;
1511 uint32_t samples;
1512} VK_IMAGE_MEMORY_REQUIREMENTS;
1513
1514typedef struct _VK_FORMAT_PROPERTIES
1515{
1516 VK_FLAGS linearTilingFeatures; // VK_FORMAT_FEATURE_FLAGS
1517 VK_FLAGS optimalTilingFeatures; // VK_FORMAT_FEATURE_FLAGS
1518} VK_FORMAT_PROPERTIES;
1519
1520typedef struct _VK_BUFFER_VIEW_ATTACH_INFO
1521{
1522 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO
1523 const void* pNext; // Pointer to next structure
1524 VK_BUFFER_VIEW view;
1525} VK_BUFFER_VIEW_ATTACH_INFO;
1526
1527typedef struct _VK_IMAGE_VIEW_ATTACH_INFO
1528{
1529 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
1530 const void* pNext; // Pointer to next structure
1531 VK_IMAGE_VIEW view;
1532 VK_IMAGE_LAYOUT layout;
1533} VK_IMAGE_VIEW_ATTACH_INFO;
1534
1535typedef struct _VK_UPDATE_SAMPLERS
1536{
1537 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLERS
1538 const void* pNext; // Pointer to next structure
1539 uint32_t binding; // Binding of the sampler (array)
1540 uint32_t arrayIndex; // First element of the array to update or zero otherwise
1541 uint32_t count; // Number of elements to update
1542 const VK_SAMPLER* pSamplers;
1543} VK_UPDATE_SAMPLERS;
1544
1545typedef struct _VK_SAMPLER_IMAGE_VIEW_INFO
1546{
1547 VK_SAMPLER sampler;
1548 const VK_IMAGE_VIEW_ATTACH_INFO* pImageView;
1549} VK_SAMPLER_IMAGE_VIEW_INFO;
1550
1551typedef struct _VK_UPDATE_SAMPLER_TEXTURES
1552{
1553 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES
1554 const void* pNext; // Pointer to next structure
1555 uint32_t binding; // Binding of the combined texture sampler (array)
1556 uint32_t arrayIndex; // First element of the array to update or zero otherwise
1557 uint32_t count; // Number of elements to update
1558 const VK_SAMPLER_IMAGE_VIEW_INFO* pSamplerImageViews;
1559} VK_UPDATE_SAMPLER_TEXTURES;
1560
1561typedef struct _VK_UPDATE_IMAGES
1562{
1563 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES
1564 const void* pNext; // Pointer to next structure
1565 VK_DESCRIPTOR_TYPE descriptorType;
1566 uint32_t binding; // Binding of the image (array)
1567 uint32_t arrayIndex; // First element of the array to update or zero otherwise
1568 uint32_t count; // Number of elements to update
1569 const VK_IMAGE_VIEW_ATTACH_INFO* pImageViews;
1570} VK_UPDATE_IMAGES;
1571
1572typedef struct _VK_UPDATE_BUFFERS
1573{
1574 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS
1575 const void* pNext; // Pointer to next structure
1576 VK_DESCRIPTOR_TYPE descriptorType;
1577 uint32_t binding; // Binding of the buffer (array)
1578 uint32_t arrayIndex; // First element of the array to update or zero otherwise
1579 uint32_t count; // Number of elements to update
1580 const VK_BUFFER_VIEW_ATTACH_INFO* pBufferViews;
1581} VK_UPDATE_BUFFERS;
1582
1583typedef struct _VK_UPDATE_AS_COPY
1584{
1585 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY
1586 const void* pNext; // Pointer to next structure
1587 VK_DESCRIPTOR_TYPE descriptorType;
1588 VK_DESCRIPTOR_SET descriptorSet;
1589 uint32_t binding;
1590 uint32_t arrayElement;
1591 uint32_t count;
1592} VK_UPDATE_AS_COPY;
1593
1594typedef struct _VK_BUFFER_CREATE_INFO
1595{
1596 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
1597 const void* pNext; // Pointer to next structure.
1598 VK_GPU_SIZE size; // Specified in bytes
1599 VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS
1600 VK_FLAGS flags; // VK_BUFFER_CREATE_FLAGS
1601} VK_BUFFER_CREATE_INFO;
1602
1603typedef struct _VK_BUFFER_VIEW_CREATE_INFO
1604{
1605 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
1606 const void* pNext; // Pointer to next structure.
1607 VK_BUFFER buffer;
1608 VK_BUFFER_VIEW_TYPE viewType;
1609 VK_FORMAT format; // Optionally specifies format of elements
1610 VK_GPU_SIZE offset; // Specified in bytes
1611 VK_GPU_SIZE range; // View size specified in bytes
1612} VK_BUFFER_VIEW_CREATE_INFO;
1613
1614typedef struct _VK_IMAGE_SUBRESOURCE
1615{
1616 VK_IMAGE_ASPECT aspect;
1617 uint32_t mipLevel;
1618 uint32_t arraySlice;
1619} VK_IMAGE_SUBRESOURCE;
1620
1621typedef struct _VK_IMAGE_SUBRESOURCE_RANGE
1622{
1623 VK_IMAGE_ASPECT aspect;
1624 uint32_t baseMipLevel;
1625 uint32_t mipLevels;
1626 uint32_t baseArraySlice;
1627 uint32_t arraySize;
1628} VK_IMAGE_SUBRESOURCE_RANGE;
1629
1630typedef struct _VK_EVENT_WAIT_INFO
1631{
1632 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_WAIT_INFO
1633 const void* pNext; // Pointer to next structure.
1634
1635 uint32_t eventCount; // Number of events to wait on
1636 const VK_EVENT* pEvents; // Array of event objects to wait on
1637
1638 VK_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen
1639
1640 uint32_t memBarrierCount; // Number of memory barriers
1641 const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER)
1642} VK_EVENT_WAIT_INFO;
1643
1644typedef struct _VK_PIPELINE_BARRIER
1645{
1646 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_BARRIER
1647 const void* pNext; // Pointer to next structure.
1648
1649 uint32_t eventCount; // Number of events to wait on
1650 const VK_PIPE_EVENT* pEvents; // Array of pipeline events to wait on
1651
1652 VK_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen
1653
1654 uint32_t memBarrierCount; // Number of memory barriers
1655 const void** ppMemBarriers; // Array of pointers to memory barriers (any of them can be either VK_MEMORY_BARRIER, VK_BUFFER_MEMORY_BARRIER, or VK_IMAGE_MEMORY_BARRIER)
1656} VK_PIPELINE_BARRIER;
1657
1658typedef struct _VK_MEMORY_BARRIER
1659{
1660 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER
1661 const void* pNext; // Pointer to next structure.
1662
1663 VK_FLAGS outputMask; // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS)
1664 VK_FLAGS inputMask; // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS)
1665} VK_MEMORY_BARRIER;
1666
1667typedef struct _VK_BUFFER_MEMORY_BARRIER
1668{
1669 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
1670 const void* pNext; // Pointer to next structure.
1671
1672 VK_FLAGS outputMask; // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS)
1673 VK_FLAGS inputMask; // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS)
1674
1675 VK_BUFFER buffer; // Buffer to sync
1676
1677 VK_GPU_SIZE offset; // Offset within the buffer to sync
1678 VK_GPU_SIZE size; // Amount of bytes to sync
1679} VK_BUFFER_MEMORY_BARRIER;
1680
1681typedef struct _VK_IMAGE_MEMORY_BARRIER
1682{
1683 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
1684 const void* pNext; // Pointer to next structure.
1685
1686 VK_FLAGS outputMask; // Outputs the barrier should sync (see VK_MEMORY_OUTPUT_FLAGS)
1687 VK_FLAGS inputMask; // Inputs the barrier should sync to (see VK_MEMORY_INPUT_FLAGS)
1688
1689 VK_IMAGE_LAYOUT oldLayout; // Current layout of the image
1690 VK_IMAGE_LAYOUT newLayout; // New layout to transition the image to
1691
1692 VK_IMAGE image; // Image to sync
1693
1694 VK_IMAGE_SUBRESOURCE_RANGE subresourceRange; // Subresource range to sync
1695} VK_IMAGE_MEMORY_BARRIER;
1696
1697typedef struct _VK_IMAGE_CREATE_INFO
1698{
1699 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
1700 const void* pNext; // Pointer to next structure.
1701 VK_IMAGE_TYPE imageType;
1702 VK_FORMAT format;
1703 VK_EXTENT3D extent;
1704 uint32_t mipLevels;
1705 uint32_t arraySize;
1706 uint32_t samples;
1707 VK_IMAGE_TILING tiling;
1708 VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS
1709 VK_FLAGS flags; // VK_IMAGE_CREATE_FLAGS
1710} VK_IMAGE_CREATE_INFO;
1711
1712typedef struct _VK_PEER_IMAGE_OPEN_INFO
1713{
1714 VK_IMAGE originalImage;
1715} VK_PEER_IMAGE_OPEN_INFO;
1716
1717typedef struct _VK_SUBRESOURCE_LAYOUT
1718{
1719 VK_GPU_SIZE offset; // Specified in bytes
1720 VK_GPU_SIZE size; // Specified in bytes
1721 VK_GPU_SIZE rowPitch; // Specified in bytes
1722 VK_GPU_SIZE depthPitch; // Specified in bytes
1723} VK_SUBRESOURCE_LAYOUT;
1724
1725typedef struct _VK_IMAGE_VIEW_CREATE_INFO
1726{
1727 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
1728 const void* pNext; // Pointer to next structure
1729 VK_IMAGE image;
1730 VK_IMAGE_VIEW_TYPE viewType;
1731 VK_FORMAT format;
1732 VK_CHANNEL_MAPPING channels;
1733 VK_IMAGE_SUBRESOURCE_RANGE subresourceRange;
1734 float minLod;
1735} VK_IMAGE_VIEW_CREATE_INFO;
1736
1737typedef struct _VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1738{
1739 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1740 const void* pNext; // Pointer to next structure
1741 VK_IMAGE image;
1742 VK_FORMAT format;
1743 uint32_t mipLevel;
1744 uint32_t baseArraySlice;
1745 uint32_t arraySize;
1746 VK_IMAGE msaaResolveImage;
1747 VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource;
1748} VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO;
1749
1750typedef struct _VK_DEPTH_STENCIL_VIEW_CREATE_INFO
1751{
1752 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
1753 const void* pNext; // Pointer to next structure
1754 VK_IMAGE image;
1755 uint32_t mipLevel;
1756 uint32_t baseArraySlice;
1757 uint32_t arraySize;
1758 VK_IMAGE msaaResolveImage;
1759 VK_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource;
1760 VK_FLAGS flags; // VK_DEPTH_STENCIL_VIEW_CREATE_FLAGS
1761} VK_DEPTH_STENCIL_VIEW_CREATE_INFO;
1762
1763typedef struct _VK_COLOR_ATTACHMENT_BIND_INFO
1764{
1765 VK_COLOR_ATTACHMENT_VIEW view;
1766 VK_IMAGE_LAYOUT layout;
1767} VK_COLOR_ATTACHMENT_BIND_INFO;
1768
1769typedef struct _VK_DEPTH_STENCIL_BIND_INFO
1770{
1771 VK_DEPTH_STENCIL_VIEW view;
1772 VK_IMAGE_LAYOUT layout;
1773} VK_DEPTH_STENCIL_BIND_INFO;
1774
1775typedef struct _VK_BUFFER_COPY
1776{
1777 VK_GPU_SIZE srcOffset; // Specified in bytes
1778 VK_GPU_SIZE destOffset; // Specified in bytes
1779 VK_GPU_SIZE copySize; // Specified in bytes
1780} VK_BUFFER_COPY;
1781
1782typedef struct _VK_IMAGE_MEMORY_BIND_INFO
1783{
1784 VK_IMAGE_SUBRESOURCE subresource;
1785 VK_OFFSET3D offset;
1786 VK_EXTENT3D extent;
1787} VK_IMAGE_MEMORY_BIND_INFO;
1788
1789typedef struct _VK_IMAGE_COPY
1790{
1791 VK_IMAGE_SUBRESOURCE srcSubresource;
1792 VK_OFFSET3D srcOffset;
1793 VK_IMAGE_SUBRESOURCE destSubresource;
1794 VK_OFFSET3D destOffset;
1795 VK_EXTENT3D extent;
1796} VK_IMAGE_COPY;
1797
1798typedef struct _VK_IMAGE_BLIT
1799{
1800 VK_IMAGE_SUBRESOURCE srcSubresource;
1801 VK_OFFSET3D srcOffset;
1802 VK_EXTENT3D srcExtent;
1803 VK_IMAGE_SUBRESOURCE destSubresource;
1804 VK_OFFSET3D destOffset;
1805 VK_EXTENT3D destExtent;
1806} VK_IMAGE_BLIT;
1807
1808typedef struct _VK_BUFFER_IMAGE_COPY
1809{
1810 VK_GPU_SIZE bufferOffset; // Specified in bytes
1811 VK_IMAGE_SUBRESOURCE imageSubresource;
1812 VK_OFFSET3D imageOffset;
1813 VK_EXTENT3D imageExtent;
1814} VK_BUFFER_IMAGE_COPY;
1815
1816typedef struct _VK_IMAGE_RESOLVE
1817{
1818 VK_IMAGE_SUBRESOURCE srcSubresource;
1819 VK_OFFSET2D srcOffset;
1820 VK_IMAGE_SUBRESOURCE destSubresource;
1821 VK_OFFSET2D destOffset;
1822 VK_EXTENT2D extent;
1823} VK_IMAGE_RESOLVE;
1824
1825typedef struct _VK_SHADER_CREATE_INFO
1826{
1827 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO
1828 const void* pNext; // Pointer to next structure
1829 size_t codeSize; // Specified in bytes
1830 const void* pCode;
1831 VK_FLAGS flags; // Reserved
1832} VK_SHADER_CREATE_INFO;
1833
1834typedef struct _VK_DESCRIPTOR_SET_LAYOUT_BINDING
1835{
1836 VK_DESCRIPTOR_TYPE descriptorType;
1837 uint32_t count;
1838 VK_FLAGS stageFlags; // VK_SHADER_STAGE_FLAGS
1839 const VK_SAMPLER* pImmutableSamplers;
1840} VK_DESCRIPTOR_SET_LAYOUT_BINDING;
1841
1842typedef struct _VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
1843{
1844 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
1845 const void* pNext; // Pointer to next structure
1846 uint32_t count; // Number of bindings in the descriptor set layout
1847 const VK_DESCRIPTOR_SET_LAYOUT_BINDING* pBinding; // Array of descriptor set layout bindings
1848} VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
1849
1850typedef struct _VK_DESCRIPTOR_TYPE_COUNT
1851{
1852 VK_DESCRIPTOR_TYPE type;
1853 uint32_t count;
1854} VK_DESCRIPTOR_TYPE_COUNT;
1855
1856typedef struct _VK_DESCRIPTOR_POOL_CREATE_INFO
1857{
1858 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
1859 const void* pNext; // Pointer to next structure
1860 uint32_t count;
1861 const VK_DESCRIPTOR_TYPE_COUNT* pTypeCount;
1862} VK_DESCRIPTOR_POOL_CREATE_INFO;
1863
1864typedef struct _VK_LINK_CONST_BUFFER
1865{
1866 uint32_t bufferId;
1867 size_t bufferSize;
1868 const void* pBufferData;
1869} VK_LINK_CONST_BUFFER;
1870
1871typedef struct _VK_SPECIALIZATION_MAP_ENTRY
1872{
1873 uint32_t constantId; // The SpecConstant ID specified in the BIL
1874 uint32_t offset; // Offset of the value in the data block
1875} VK_SPECIALIZATION_MAP_ENTRY;
1876
1877typedef struct _VK_SPECIALIZATION_INFO
1878{
1879 uint32_t mapEntryCount;
1880 const VK_SPECIALIZATION_MAP_ENTRY* pMap; // mapEntryCount entries
1881 const void* pData;
1882} VK_SPECIALIZATION_INFO;
1883
1884typedef struct _VK_PIPELINE_SHADER
1885{
1886 VK_PIPELINE_SHADER_STAGE stage;
1887 VK_SHADER shader;
1888 uint32_t linkConstBufferCount;
1889 const VK_LINK_CONST_BUFFER* pLinkConstBufferInfo;
1890 const VK_SPECIALIZATION_INFO* pSpecializationInfo;
1891} VK_PIPELINE_SHADER;
1892
1893typedef struct _VK_COMPUTE_PIPELINE_CREATE_INFO
1894{
1895 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
1896 const void* pNext; // Pointer to next structure
1897 VK_PIPELINE_SHADER cs;
1898 VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS
1899 VK_DESCRIPTOR_SET_LAYOUT_CHAIN setLayoutChain; // For local size fields zero is treated an invalid value
1900 uint32_t localSizeX;
1901 uint32_t localSizeY;
1902 uint32_t localSizeZ;
1903
1904} VK_COMPUTE_PIPELINE_CREATE_INFO;
1905
1906typedef struct _VK_VERTEX_INPUT_BINDING_DESCRIPTION
1907{
1908 uint32_t binding; // Vertex buffer binding id
1909 uint32_t strideInBytes; // Distance between vertices in bytes (0 = no advancement)
1910
1911 VK_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented
1912} VK_VERTEX_INPUT_BINDING_DESCRIPTION;
1913
1914typedef struct _VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION
1915{
1916 uint32_t location; // location of the shader vertex attrib
1917 uint32_t binding; // Vertex buffer binding id
1918
1919 VK_FORMAT format; // format of source data
1920
1921 uint32_t offsetInBytes; // Offset of first element in bytes from base of vertex
1922} VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION;
1923
1924typedef struct _VK_PIPELINE_VERTEX_INPUT_CREATE_INFO
1925{
1926 VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
1927 const void* pNext; // Pointer to next structure
1928
1929 uint32_t bindingCount; // number of bindings
1930 const VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions;
1931
1932 uint32_t attributeCount; // number of attributes
1933 const VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
1934} VK_PIPELINE_VERTEX_INPUT_CREATE_INFO;
1935
1936typedef struct _VK_PIPELINE_IA_STATE_CREATE_INFO
1937{
1938 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
1939 const void* pNext; // Pointer to next structure
1940 VK_PRIMITIVE_TOPOLOGY topology;
1941 bool32_t disableVertexReuse; // optional
1942 bool32_t primitiveRestartEnable;
1943 uint32_t primitiveRestartIndex; // optional (GL45)
1944} VK_PIPELINE_IA_STATE_CREATE_INFO;
1945
1946typedef struct _VK_PIPELINE_TESS_STATE_CREATE_INFO
1947{
1948 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
1949 const void* pNext; // Pointer to next structure
1950 uint32_t patchControlPoints;
1951} VK_PIPELINE_TESS_STATE_CREATE_INFO;
1952
1953typedef struct _VK_PIPELINE_VP_STATE_CREATE_INFO
1954{
1955 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO
1956 const void* pNext; // Pointer to next structure
1957 uint32_t numViewports;
1958 VK_COORDINATE_ORIGIN clipOrigin; // optional (GL45)
1959 VK_DEPTH_MODE depthMode; // optional (GL45)
1960} VK_PIPELINE_VP_STATE_CREATE_INFO;
1961
1962typedef struct _VK_PIPELINE_RS_STATE_CREATE_INFO
1963{
1964 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
1965 const void* pNext; // Pointer to next structure
1966 bool32_t depthClipEnable;
1967 bool32_t rasterizerDiscardEnable;
1968 bool32_t programPointSize; // optional (GL45)
1969 VK_COORDINATE_ORIGIN pointOrigin; // optional (GL45)
1970 VK_PROVOKING_VERTEX_CONVENTION provokingVertex; // optional (GL45)
1971 VK_FILL_MODE fillMode; // optional (GL45)
1972 VK_CULL_MODE cullMode;
1973 VK_FACE_ORIENTATION frontFace;
1974} VK_PIPELINE_RS_STATE_CREATE_INFO;
1975
1976typedef struct _VK_PIPELINE_MS_STATE_CREATE_INFO
1977{
1978 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO
1979 const void* pNext; // Pointer to next structure
1980 uint32_t samples;
1981 bool32_t multisampleEnable; // optional (GL45)
1982 bool32_t sampleShadingEnable; // optional (GL45)
1983 float minSampleShading; // optional (GL45)
1984 VK_SAMPLE_MASK sampleMask;
1985} VK_PIPELINE_MS_STATE_CREATE_INFO;
1986
1987typedef struct _VK_PIPELINE_CB_ATTACHMENT_STATE
1988{
1989 bool32_t blendEnable;
1990 VK_FORMAT format;
1991 VK_BLEND srcBlendColor;
1992 VK_BLEND destBlendColor;
1993 VK_BLEND_FUNC blendFuncColor;
1994 VK_BLEND srcBlendAlpha;
1995 VK_BLEND destBlendAlpha;
1996 VK_BLEND_FUNC blendFuncAlpha;
1997 uint8_t channelWriteMask;
1998} VK_PIPELINE_CB_ATTACHMENT_STATE;
1999
2000typedef struct _VK_PIPELINE_CB_STATE_CREATE_INFO
2001{
2002 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
2003 const void* pNext; // Pointer to next structure
2004 bool32_t alphaToCoverageEnable;
2005 bool32_t logicOpEnable;
2006 VK_LOGIC_OP logicOp;
2007 uint32_t attachmentCount; // # of pAttachments
2008 const VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments;
2009} VK_PIPELINE_CB_STATE_CREATE_INFO;
2010
2011typedef struct _VK_STENCIL_OP_STATE
2012{
2013 VK_STENCIL_OP stencilFailOp;
2014 VK_STENCIL_OP stencilPassOp;
2015 VK_STENCIL_OP stencilDepthFailOp;
2016 VK_COMPARE_FUNC stencilFunc;
2017} VK_STENCIL_OP_STATE;
2018
2019typedef struct _VK_PIPELINE_DS_STATE_CREATE_INFO
2020{
2021 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO
2022 const void* pNext; // Pointer to next structure
2023 VK_FORMAT format;
2024 bool32_t depthTestEnable;
2025 bool32_t depthWriteEnable;
2026 VK_COMPARE_FUNC depthFunc;
2027 bool32_t depthBoundsEnable; // optional (depth_bounds_test)
2028 bool32_t stencilTestEnable;
2029 VK_STENCIL_OP_STATE front;
2030 VK_STENCIL_OP_STATE back;
2031} VK_PIPELINE_DS_STATE_CREATE_INFO;
2032
2033typedef struct _VK_PIPELINE_SHADER_STAGE_CREATE_INFO
2034{
2035 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
2036 const void* pNext; // Pointer to next structure
2037 VK_PIPELINE_SHADER shader;
2038} VK_PIPELINE_SHADER_STAGE_CREATE_INFO;
2039
2040typedef struct _VK_GRAPHICS_PIPELINE_CREATE_INFO
2041{
2042 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
2043 const void* pNext; // Pointer to next structure
2044 VK_FLAGS flags; // VK_PIPELINE_CREATE_FLAGS
2045 VK_DESCRIPTOR_SET_LAYOUT_CHAIN pSetLayoutChain;
2046} VK_GRAPHICS_PIPELINE_CREATE_INFO;
2047
2048typedef struct _VK_SAMPLER_CREATE_INFO
2049{
2050 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
2051 const void* pNext; // Pointer to next structure
2052 VK_TEX_FILTER magFilter; // Filter mode for magnification
2053 VK_TEX_FILTER minFilter; // Filter mode for minifiation
2054 VK_TEX_MIPMAP_MODE mipMode; // Mipmap selection mode
2055 VK_TEX_ADDRESS addressU;
2056 VK_TEX_ADDRESS addressV;
2057 VK_TEX_ADDRESS addressW;
2058 float mipLodBias;
2059 uint32_t maxAnisotropy;
2060 VK_COMPARE_FUNC compareFunc;
2061 float minLod;
2062 float maxLod;
2063 VK_BORDER_COLOR_TYPE borderColorType;
2064} VK_SAMPLER_CREATE_INFO;
2065
2066typedef struct _VK_DYNAMIC_VP_STATE_CREATE_INFO
2067{
2068 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO
2069 const void* pNext; // Pointer to next structure
2070 uint32_t viewportAndScissorCount; // number of entries in pViewports and pScissors
2071 const VK_VIEWPORT* pViewports;
2072 const VK_RECT* pScissors;
2073} VK_DYNAMIC_VP_STATE_CREATE_INFO;
2074
2075typedef struct _VK_DYNAMIC_RS_STATE_CREATE_INFO
2076{
2077 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
2078 const void* pNext; // Pointer to next structure
2079 float depthBias;
2080 float depthBiasClamp;
2081 float slopeScaledDepthBias;
2082 float pointSize; // optional (GL45) - Size of points
2083 float pointFadeThreshold; // optional (GL45) - Size of point fade threshold
2084 float lineWidth; // optional (GL45) - Width of lines
2085} VK_DYNAMIC_RS_STATE_CREATE_INFO;
2086
2087typedef struct _VK_DYNAMIC_CB_STATE_CREATE_INFO
2088{
2089 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO
2090 const void* pNext; // Pointer to next structure
2091 float blendConst[4];
2092} VK_DYNAMIC_CB_STATE_CREATE_INFO;
2093
2094typedef struct _VK_DYNAMIC_DS_STATE_CREATE_INFO
2095{
2096 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO
2097 const void* pNext; // Pointer to next structure
2098 float minDepth; // optional (depth_bounds_test)
2099 float maxDepth; // optional (depth_bounds_test)
2100 uint32_t stencilReadMask;
2101 uint32_t stencilWriteMask;
2102 uint32_t stencilFrontRef;
2103 uint32_t stencilBackRef;
2104} VK_DYNAMIC_DS_STATE_CREATE_INFO;
2105
2106typedef struct _VK_CMD_BUFFER_CREATE_INFO
2107{
2108 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
2109 const void* pNext; // Pointer to next structure
2110 uint32_t queueNodeIndex;
2111 VK_FLAGS flags;
2112} VK_CMD_BUFFER_CREATE_INFO;
2113
2114typedef struct _VK_CMD_BUFFER_BEGIN_INFO
2115{
2116 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
2117 const void* pNext; // Pointer to next structure
2118
2119 VK_FLAGS flags; // VK_CMD_BUFFER_BUILD_FLAGS
2120} VK_CMD_BUFFER_BEGIN_INFO;
2121
2122typedef struct _VK_RENDER_PASS_BEGIN
2123{
2124 VK_RENDER_PASS renderPass;
2125 VK_FRAMEBUFFER framebuffer;
2126} VK_RENDER_PASS_BEGIN;
2127
2128typedef struct _VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO
2129{
2130 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO
2131 const void* pNext; // Pointer to next structure
2132
2133 VK_RENDER_PASS_BEGIN renderPassContinue; // Only needed when a render pass is split across two command buffers
2134} VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
2135
2136// Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared.
2137typedef union _VK_CLEAR_COLOR_VALUE
2138{
2139 float floatColor[4];
2140 uint32_t rawColor[4];
2141} VK_CLEAR_COLOR_VALUE;
2142
2143typedef struct _VK_CLEAR_COLOR
2144{
2145 VK_CLEAR_COLOR_VALUE color;
2146 bool32_t useRawValue;
2147} VK_CLEAR_COLOR;
2148
2149typedef struct _VK_RENDER_PASS_CREATE_INFO
2150{
2151 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
2152 const void* pNext; // Pointer to next structure
2153
2154 VK_RECT renderArea;
2155 uint32_t colorAttachmentCount;
2156 VK_EXTENT2D extent;
2157 uint32_t sampleCount;
2158 uint32_t layers;
2159 const VK_FORMAT* pColorFormats;
2160 const VK_IMAGE_LAYOUT* pColorLayouts;
2161 const VK_ATTACHMENT_LOAD_OP* pColorLoadOps;
2162 const VK_ATTACHMENT_STORE_OP* pColorStoreOps;
2163 const VK_CLEAR_COLOR* pColorLoadClearValues;
2164 VK_FORMAT depthStencilFormat;
2165 VK_IMAGE_LAYOUT depthStencilLayout;
2166 VK_ATTACHMENT_LOAD_OP depthLoadOp;
2167 float depthLoadClearValue;
2168 VK_ATTACHMENT_STORE_OP depthStoreOp;
2169 VK_ATTACHMENT_LOAD_OP stencilLoadOp;
2170 uint32_t stencilLoadClearValue;
2171 VK_ATTACHMENT_STORE_OP stencilStoreOp;
2172} VK_RENDER_PASS_CREATE_INFO;
2173
2174typedef struct _VK_EVENT_CREATE_INFO
2175{
2176 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
2177 const void* pNext; // Pointer to next structure
2178 VK_FLAGS flags; // Reserved
2179} VK_EVENT_CREATE_INFO;
2180
2181typedef struct _VK_FENCE_CREATE_INFO
2182{
2183 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
2184 const void* pNext; // Pointer to next structure
2185 VK_FENCE_CREATE_FLAGS flags; // VK_FENCE_CREATE_FLAGS
2186} VK_FENCE_CREATE_INFO;
2187
2188typedef struct _VK_SEMAPHORE_CREATE_INFO
2189{
2190 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
2191 const void* pNext; // Pointer to next structure
2192 uint32_t initialCount;
2193 VK_FLAGS flags; // VK_SEMAPHORE_CREATE_FLAGS
2194} VK_SEMAPHORE_CREATE_INFO;
2195
2196typedef struct _VK_SEMAPHORE_OPEN_INFO
2197{
2198 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
2199 const void* pNext; // Pointer to next structure
2200 VK_SEMAPHORE sharedSemaphore;
2201} VK_SEMAPHORE_OPEN_INFO;
2202
2203typedef struct _VK_PIPELINE_STATISTICS_DATA
2204{
2205 uint64_t fsInvocations; // Fragment shader invocations
2206 uint64_t cPrimitives; // Clipper primitives
2207 uint64_t cInvocations; // Clipper invocations
2208 uint64_t vsInvocations; // Vertex shader invocations
2209 uint64_t gsInvocations; // Geometry shader invocations
2210 uint64_t gsPrimitives; // Geometry shader primitives
2211 uint64_t iaPrimitives; // Input primitives
2212 uint64_t iaVertices; // Input vertices
2213 uint64_t tcsInvocations; // Tessellation control shader invocations
2214 uint64_t tesInvocations; // Tessellation evaluation shader invocations
2215 uint64_t csInvocations; // Compute shader invocations
2216} VK_PIPELINE_STATISTICS_DATA;
2217
2218typedef struct _VK_QUERY_POOL_CREATE_INFO
2219{
2220 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
2221 const void* pNext; // Pointer to next structure
2222 VK_QUERY_TYPE queryType;
2223 uint32_t slots;
2224} VK_QUERY_POOL_CREATE_INFO;
2225
2226typedef struct _VK_FRAMEBUFFER_CREATE_INFO
2227{
2228 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
2229 const void* pNext; // Pointer to next structure
2230
2231 uint32_t colorAttachmentCount;
2232 const VK_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments;
2233 const VK_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment;
2234
2235 uint32_t sampleCount;
2236 uint32_t width;
2237 uint32_t height;
2238 uint32_t layers;
2239} VK_FRAMEBUFFER_CREATE_INFO;
2240
2241typedef struct _VK_DRAW_INDIRECT_CMD
2242{
2243 uint32_t vertexCount;
2244 uint32_t instanceCount;
2245 uint32_t firstVertex;
2246 uint32_t firstInstance;
2247} VK_DRAW_INDIRECT_CMD;
2248
2249typedef struct _VK_DRAW_INDEXED_INDIRECT_CMD
2250{
2251 uint32_t indexCount;
2252 uint32_t instanceCount;
2253 uint32_t firstIndex;
2254 int32_t vertexOffset;
2255 uint32_t firstInstance;
2256} VK_DRAW_INDEXED_INDIRECT_CMD;
2257
2258typedef struct _VK_DISPATCH_INDIRECT_CMD
2259{
2260 uint32_t x;
2261 uint32_t y;
2262 uint32_t z;
2263} VK_DISPATCH_INDIRECT_CMD;
2264
2265// ------------------------------------------------------------------------------------------------
2266// API functions
2267typedef VK_RESULT (VKAPI *vkCreateInstanceType)(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance);
2268typedef VK_RESULT (VKAPI *vkDestroyInstanceType)(VK_INSTANCE instance);
2269typedef VK_RESULT (VKAPI *vkEnumerateGpusType)(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus);
2270typedef VK_RESULT (VKAPI *vkGetGpuInfoType)(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData);
2271typedef void * (VKAPI *vkGetProcAddrType)(VK_PHYSICAL_GPU gpu, const char * pName);
2272typedef VK_RESULT (VKAPI *vkCreateDeviceType)(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice);
2273typedef VK_RESULT (VKAPI *vkDestroyDeviceType)(VK_DEVICE device);
2274typedef VK_RESULT (VKAPI *vkGetExtensionSupportType)(VK_PHYSICAL_GPU gpu, const char* pExtName);
2275typedef VK_RESULT (VKAPI *vkEnumerateLayersType)(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved);
2276typedef VK_RESULT (VKAPI *vkGetDeviceQueueType)(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue);
2277typedef VK_RESULT (VKAPI *vkQueueSubmitType)(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence);
2278typedef VK_RESULT (VKAPI *vkQueueAddMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem);
2279typedef VK_RESULT (VKAPI *vkQueueRemoveMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem);
2280typedef VK_RESULT (VKAPI *vkQueueWaitIdleType)(VK_QUEUE queue);
2281typedef VK_RESULT (VKAPI *vkDeviceWaitIdleType)(VK_DEVICE device);
2282typedef VK_RESULT (VKAPI *vkAllocMemoryType)(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem);
2283typedef VK_RESULT (VKAPI *vkFreeMemoryType)(VK_GPU_MEMORY mem);
2284typedef VK_RESULT (VKAPI *vkSetMemoryPriorityType)(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority);
2285typedef VK_RESULT (VKAPI *vkMapMemoryType)(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData);
2286typedef VK_RESULT (VKAPI *vkUnmapMemoryType)(VK_GPU_MEMORY mem);
2287typedef VK_RESULT (VKAPI *vkPinSystemMemoryType)(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem);
2288typedef VK_RESULT (VKAPI *vkGetMultiGpuCompatibilityType)(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo);
2289typedef VK_RESULT (VKAPI *vkOpenSharedMemoryType)(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem);
2290typedef VK_RESULT (VKAPI *vkOpenSharedSemaphoreType)(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore);
2291typedef VK_RESULT (VKAPI *vkOpenPeerMemoryType)(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem);
2292typedef VK_RESULT (VKAPI *vkOpenPeerImageType)(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem);
2293typedef VK_RESULT (VKAPI *vkDestroyObjectType)(VK_OBJECT object);
2294typedef VK_RESULT (VKAPI *vkGetObjectInfoType)(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData);
2295typedef VK_RESULT (VKAPI *vkBindObjectMemoryType)(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset);
2296typedef VK_RESULT (VKAPI *vkBindObjectMemoryRangeType)(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset,VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset);
2297typedef VK_RESULT (VKAPI *vkBindImageMemoryRangeType)(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset);
2298typedef VK_RESULT (VKAPI *vkCreateFenceType)(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence);
2299typedef VK_RESULT (VKAPI *vkResetFencesType)(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences);
2300typedef VK_RESULT (VKAPI *vkGetFenceStatusType)(VK_FENCE fence);
2301typedef VK_RESULT (VKAPI *vkWaitForFencesType)(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout);
2302typedef VK_RESULT (VKAPI *vkCreateSemaphoreType)(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore);
2303typedef VK_RESULT (VKAPI *vkQueueSignalSemaphoreType)(VK_QUEUE queue, VK_SEMAPHORE semaphore);
2304typedef VK_RESULT (VKAPI *vkQueueWaitSemaphoreType)(VK_QUEUE queue, VK_SEMAPHORE semaphore);
2305typedef VK_RESULT (VKAPI *vkCreateEventType)(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent);
2306typedef VK_RESULT (VKAPI *vkGetEventStatusType)(VK_EVENT event);
2307typedef VK_RESULT (VKAPI *vkSetEventType)(VK_EVENT event);
2308typedef VK_RESULT (VKAPI *vkResetEventType)(VK_EVENT event);
2309typedef VK_RESULT (VKAPI *vkCreateQueryPoolType)(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool);
2310typedef VK_RESULT (VKAPI *vkGetQueryPoolResultsType)(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData);
2311typedef VK_RESULT (VKAPI *vkGetFormatInfoType)(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData);
2312typedef VK_RESULT (VKAPI *vkCreateBufferType)(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer);
2313typedef VK_RESULT (VKAPI *vkCreateBufferViewType)(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView);
2314typedef VK_RESULT (VKAPI *vkCreateImageType)(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage);
2315typedef VK_RESULT (VKAPI *vkGetImageSubresourceInfoType)(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData);
2316typedef VK_RESULT (VKAPI *vkCreateImageViewType)(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView);
2317typedef VK_RESULT (VKAPI *vkCreateColorAttachmentViewType)(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView);
2318typedef VK_RESULT (VKAPI *vkCreateDepthStencilViewType)(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView);
2319typedef VK_RESULT (VKAPI *vkCreateShaderType)(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader);
2320typedef VK_RESULT (VKAPI *vkCreateGraphicsPipelineType)(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline);
2321typedef VK_RESULT (VKAPI *vkCreateGraphicsPipelineDerivativeType)(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline);
2322typedef VK_RESULT (VKAPI *vkCreateComputePipelineType)(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline);
2323typedef VK_RESULT (VKAPI *vkStorePipelineType)(VK_PIPELINE pipeline, size_t* pDataSize, void* pData);
2324typedef VK_RESULT (VKAPI *vkLoadPipelineType)(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline);
2325typedef VK_RESULT (VKAPI *vkLoadPipelineDerivativeType)(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline);
2326typedef VK_RESULT (VKAPI *vkCreateSamplerType)(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler);
2327typedef VK_RESULT (VKAPI *vkCreateDescriptorSetLayoutType)(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout);
2328typedef VK_RESULT (VKAPI *vkCreateDescriptorSetLayoutChainType)(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain);
2329typedef VK_RESULT (VKAPI *vkBeginDescriptorPoolUpdateType)(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode);
2330typedef VK_RESULT (VKAPI *vkEndDescriptorPoolUpdateType)(VK_DEVICE device, VK_CMD_BUFFER cmd);
2331typedef VK_RESULT (VKAPI *vkCreateDescriptorPoolType)(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool);
2332typedef VK_RESULT (VKAPI *vkResetDescriptorPoolType)(VK_DESCRIPTOR_POOL descriptorPool);
2333typedef VK_RESULT (VKAPI *vkAllocDescriptorSetsType)(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount);
2334typedef void (VKAPI *vkClearDescriptorSetsType)(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets);
2335typedef void (VKAPI *vkUpdateDescriptorsType)(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray);
2336typedef VK_RESULT (VKAPI *vkCreateDynamicViewportStateType)(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState);
2337typedef VK_RESULT (VKAPI *vkCreateDynamicRasterStateType)(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState);
2338typedef VK_RESULT (VKAPI *vkCreateDynamicColorBlendStateType)(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState);
2339typedef VK_RESULT (VKAPI *vkCreateDynamicDepthStencilStateType)(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState);
2340typedef VK_RESULT (VKAPI *vkCreateCommandBufferType)(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer);
2341typedef VK_RESULT (VKAPI *vkBeginCommandBufferType)(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo);
2342typedef VK_RESULT (VKAPI *vkEndCommandBufferType)(VK_CMD_BUFFER cmdBuffer);
2343typedef VK_RESULT (VKAPI *vkResetCommandBufferType)(VK_CMD_BUFFER cmdBuffer);
2344typedef void (VKAPI *vkCmdBindPipelineType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline);
2345typedef void (VKAPI *vkCmdBindDynamicStateObjectType)(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state);
2346typedef void (VKAPI *vkCmdBindDescriptorSetsType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData);
2347typedef void (VKAPI *vkCmdBindIndexBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType);
2348typedef void (VKAPI *vkCmdBindVertexBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding);
2349typedef void (VKAPI *vkCmdDrawType)(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
2350typedef void (VKAPI *vkCmdDrawIndexedType)(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
2351typedef void (VKAPI *vkCmdDrawIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride);
2352typedef void (VKAPI *vkCmdDrawIndexedIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride);
2353typedef void (VKAPI *vkCmdDispatchType)(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
2354typedef void (VKAPI *vkCmdDispatchIndirectType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset);
2355typedef void (VKAPI *vkCmdCopyBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions);
2356typedef void (VKAPI *vkCmdCopyImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions);
2357typedef void (VKAPI *vkCmdBlitImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_BLIT* pRegions);
2358typedef void (VKAPI *vkCmdCopyBufferToImageType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions);
2359typedef void (VKAPI *vkCmdCopyImageToBufferType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions);
2360typedef void (VKAPI *vkCmdCloneImageDataType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout);
2361typedef void (VKAPI *vkCmdUpdateBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData);
2362typedef void (VKAPI *vkCmdFillBufferType)(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data);
2363typedef void (VKAPI *vkCmdClearColorImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges);
2364typedef void (VKAPI *vkCmdClearDepthStencilType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges);
2365typedef void (VKAPI *vkCmdResolveImageType)(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects);
2366typedef void (VKAPI *vkCmdSetEventType)(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent);
2367typedef void (VKAPI *vkCmdResetEventType)(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent);
2368typedef void (VKAPI *vkCmdWaitEventsType)(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo);
2369typedef void (VKAPI *vkCmdPipelineBarrierType)(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier);
2370typedef void (VKAPI *vkCmdBeginQueryType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags);
2371typedef void (VKAPI *vkCmdEndQueryType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot);
2372typedef void (VKAPI *vkCmdResetQueryPoolType)(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount);
2373typedef void (VKAPI *vkCmdWriteTimestampType)(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset);
2374typedef void (VKAPI *vkCmdInitAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData);
2375typedef void (VKAPI *vkCmdLoadAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset);
2376typedef void (VKAPI *vkCmdSaveAtomicCountersType)(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset);
2377typedef VK_RESULT (VKAPI *vkCreateFramebufferType)(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer);
2378typedef VK_RESULT (VKAPI *vkCreateRenderPassType)(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass);
2379typedef void (VKAPI *vkCmdBeginRenderPassType)(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN* pRenderPassBegin);
2380typedef void (VKAPI *vkCmdEndRenderPassType)(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass);
2381
2382#ifdef VK_PROTOTYPES
2383
2384// GPU initialization
2385
2386VK_RESULT VKAPI vkCreateInstance(
2387 const VK_INSTANCE_CREATE_INFO* pCreateInfo,
2388 VK_INSTANCE* pInstance);
2389
2390VK_RESULT VKAPI vkDestroyInstance(
2391 VK_INSTANCE instance);
2392
2393VK_RESULT VKAPI vkEnumerateGpus(
2394 VK_INSTANCE instance,
2395 uint32_t maxGpus,
2396 uint32_t* pGpuCount,
2397 VK_PHYSICAL_GPU* pGpus);
2398
2399VK_RESULT VKAPI vkGetGpuInfo(
2400 VK_PHYSICAL_GPU gpu,
2401 VK_PHYSICAL_GPU_INFO_TYPE infoType,
2402 size_t* pDataSize,
2403 void* pData);
2404
2405void * VKAPI vkGetProcAddr(
2406 VK_PHYSICAL_GPU gpu,
2407 const char* pName);
2408
2409// Device functions
2410
2411VK_RESULT VKAPI vkCreateDevice(
2412 VK_PHYSICAL_GPU gpu,
2413 const VK_DEVICE_CREATE_INFO* pCreateInfo,
2414 VK_DEVICE* pDevice);
2415
2416VK_RESULT VKAPI vkDestroyDevice(
2417 VK_DEVICE device);
2418
2419// Extension discovery functions
2420
2421VK_RESULT VKAPI vkGetExtensionSupport(
2422 VK_PHYSICAL_GPU gpu,
2423 const char* pExtName);
2424
2425// Layer discovery functions
2426
2427VK_RESULT VKAPI vkEnumerateLayers(
2428 VK_PHYSICAL_GPU gpu,
2429 size_t maxLayerCount,
2430 size_t maxStringSize,
2431 size_t* pOutLayerCount,
2432 char* const* pOutLayers,
2433 void* pReserved);
2434
2435// Queue functions
2436
2437VK_RESULT VKAPI vkGetDeviceQueue(
2438 VK_DEVICE device,
2439 uint32_t queueNodeIndex,
2440 uint32_t queueIndex,
2441 VK_QUEUE* pQueue);
2442
2443VK_RESULT VKAPI vkQueueSubmit(
2444 VK_QUEUE queue,
2445 uint32_t cmdBufferCount,
2446 const VK_CMD_BUFFER* pCmdBuffers,
2447 VK_FENCE fence);
2448
2449VK_RESULT VKAPI vkQueueAddMemReference(
2450 VK_QUEUE queue,
2451 VK_GPU_MEMORY mem);
2452
2453VK_RESULT VKAPI vkQueueRemoveMemReference(
2454 VK_QUEUE queue,
2455 VK_GPU_MEMORY mem);
2456
2457VK_RESULT VKAPI vkQueueWaitIdle(
2458 VK_QUEUE queue);
2459
2460VK_RESULT VKAPI vkDeviceWaitIdle(
2461 VK_DEVICE device);
2462
2463// Memory functions
2464
2465VK_RESULT VKAPI vkAllocMemory(
2466 VK_DEVICE device,
2467 const VK_MEMORY_ALLOC_INFO* pAllocInfo,
2468 VK_GPU_MEMORY* pMem);
2469
2470VK_RESULT VKAPI vkFreeMemory(
2471 VK_GPU_MEMORY mem);
2472
2473VK_RESULT VKAPI vkSetMemoryPriority(
2474 VK_GPU_MEMORY mem,
2475 VK_MEMORY_PRIORITY priority);
2476
2477VK_RESULT VKAPI vkMapMemory(
2478 VK_GPU_MEMORY mem,
2479 VK_FLAGS flags, // Reserved
2480 void** ppData);
2481
2482VK_RESULT VKAPI vkUnmapMemory(
2483 VK_GPU_MEMORY mem);
2484
2485VK_RESULT VKAPI vkPinSystemMemory(
2486 VK_DEVICE device,
2487 const void* pSysMem,
2488 size_t memSize,
2489 VK_GPU_MEMORY* pMem);
2490
2491// Multi-device functions
2492
2493VK_RESULT VKAPI vkGetMultiGpuCompatibility(
2494 VK_PHYSICAL_GPU gpu0,
2495 VK_PHYSICAL_GPU gpu1,
2496 VK_GPU_COMPATIBILITY_INFO* pInfo);
2497
2498VK_RESULT VKAPI vkOpenSharedMemory(
2499 VK_DEVICE device,
2500 const VK_MEMORY_OPEN_INFO* pOpenInfo,
2501 VK_GPU_MEMORY* pMem);
2502
2503VK_RESULT VKAPI vkOpenSharedSemaphore(
2504 VK_DEVICE device,
2505 const VK_SEMAPHORE_OPEN_INFO* pOpenInfo,
2506 VK_SEMAPHORE* pSemaphore);
2507
2508VK_RESULT VKAPI vkOpenPeerMemory(
2509 VK_DEVICE device,
2510 const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo,
2511 VK_GPU_MEMORY* pMem);
2512
2513VK_RESULT VKAPI vkOpenPeerImage(
2514 VK_DEVICE device,
2515 const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo,
2516 VK_IMAGE* pImage,
2517 VK_GPU_MEMORY* pMem);
2518
2519// Generic API object functions
2520
2521VK_RESULT VKAPI vkDestroyObject(
2522 VK_OBJECT object);
2523
2524VK_RESULT VKAPI vkGetObjectInfo(
2525 VK_BASE_OBJECT object,
2526 VK_OBJECT_INFO_TYPE infoType,
2527 size_t* pDataSize,
2528 void* pData);
2529
2530VK_RESULT VKAPI vkBindObjectMemory(
2531 VK_OBJECT object,
2532 uint32_t allocationIdx,
2533 VK_GPU_MEMORY mem,
2534 VK_GPU_SIZE memOffset);
2535
2536VK_RESULT VKAPI vkBindObjectMemoryRange(
2537 VK_OBJECT object,
2538 uint32_t allocationIdx,
2539 VK_GPU_SIZE rangeOffset,
2540 VK_GPU_SIZE rangeSize,
2541 VK_GPU_MEMORY mem,
2542 VK_GPU_SIZE memOffset);
2543
2544VK_RESULT VKAPI vkBindImageMemoryRange(
2545 VK_IMAGE image,
2546 uint32_t allocationIdx,
2547 const VK_IMAGE_MEMORY_BIND_INFO* bindInfo,
2548 VK_GPU_MEMORY mem,
2549 VK_GPU_SIZE memOffset);
2550
2551// Fence functions
2552
2553VK_RESULT VKAPI vkCreateFence(
2554 VK_DEVICE device,
2555 const VK_FENCE_CREATE_INFO* pCreateInfo,
2556 VK_FENCE* pFence);
2557
2558VK_RESULT VKAPI vkResetFences(
2559 VK_DEVICE device,
2560 uint32_t fenceCount,
2561 VK_FENCE* pFences);
2562
2563VK_RESULT VKAPI vkGetFenceStatus(
2564 VK_FENCE fence);
2565
2566VK_RESULT VKAPI vkWaitForFences(
2567 VK_DEVICE device,
2568 uint32_t fenceCount,
2569 const VK_FENCE* pFences,
2570 bool32_t waitAll,
2571 uint64_t timeout); // timeout in nanoseconds
2572
2573// Queue semaphore functions
2574
2575VK_RESULT VKAPI vkCreateSemaphore(
2576 VK_DEVICE device,
2577 const VK_SEMAPHORE_CREATE_INFO* pCreateInfo,
2578 VK_SEMAPHORE* pSemaphore);
2579
2580VK_RESULT VKAPI vkQueueSignalSemaphore(
2581 VK_QUEUE queue,
2582 VK_SEMAPHORE semaphore);
2583
2584VK_RESULT VKAPI vkQueueWaitSemaphore(
2585 VK_QUEUE queue,
2586 VK_SEMAPHORE semaphore);
2587
2588// Event functions
2589
2590VK_RESULT VKAPI vkCreateEvent(
2591 VK_DEVICE device,
2592 const VK_EVENT_CREATE_INFO* pCreateInfo,
2593 VK_EVENT* pEvent);
2594
2595VK_RESULT VKAPI vkGetEventStatus(
2596 VK_EVENT event);
2597
2598VK_RESULT VKAPI vkSetEvent(
2599 VK_EVENT event);
2600
2601VK_RESULT VKAPI vkResetEvent(
2602 VK_EVENT event);
2603
2604// Query functions
2605
2606VK_RESULT VKAPI vkCreateQueryPool(
2607 VK_DEVICE device,
2608 const VK_QUERY_POOL_CREATE_INFO* pCreateInfo,
2609 VK_QUERY_POOL* pQueryPool);
2610
2611VK_RESULT VKAPI vkGetQueryPoolResults(
2612 VK_QUERY_POOL queryPool,
2613 uint32_t startQuery,
2614 uint32_t queryCount,
2615 size_t* pDataSize,
2616 void* pData);
2617
2618// Format capabilities
2619
2620VK_RESULT VKAPI vkGetFormatInfo(
2621 VK_DEVICE device,
2622 VK_FORMAT format,
2623 VK_FORMAT_INFO_TYPE infoType,
2624 size_t* pDataSize,
2625 void* pData);
2626
2627// Buffer functions
2628
2629VK_RESULT VKAPI vkCreateBuffer(
2630 VK_DEVICE device,
2631 const VK_BUFFER_CREATE_INFO* pCreateInfo,
2632 VK_BUFFER* pBuffer);
2633
2634// Buffer view functions
2635
2636VK_RESULT VKAPI vkCreateBufferView(
2637 VK_DEVICE device,
2638 const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo,
2639 VK_BUFFER_VIEW* pView);
2640
2641// Image functions
2642
2643VK_RESULT VKAPI vkCreateImage(
2644 VK_DEVICE device,
2645 const VK_IMAGE_CREATE_INFO* pCreateInfo,
2646 VK_IMAGE* pImage);
2647
2648VK_RESULT VKAPI vkGetImageSubresourceInfo(
2649 VK_IMAGE image,
2650 const VK_IMAGE_SUBRESOURCE* pSubresource,
2651 VK_SUBRESOURCE_INFO_TYPE infoType,
2652 size_t* pDataSize,
2653 void* pData);
2654
2655// Image view functions
2656
2657VK_RESULT VKAPI vkCreateImageView(
2658 VK_DEVICE device,
2659 const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
2660 VK_IMAGE_VIEW* pView);
2661
2662VK_RESULT VKAPI vkCreateColorAttachmentView(
2663 VK_DEVICE device,
2664 const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
2665 VK_COLOR_ATTACHMENT_VIEW* pView);
2666
2667VK_RESULT VKAPI vkCreateDepthStencilView(
2668 VK_DEVICE device,
2669 const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
2670 VK_DEPTH_STENCIL_VIEW* pView);
2671
2672// Shader functions
2673
2674VK_RESULT VKAPI vkCreateShader(
2675 VK_DEVICE device,
2676 const VK_SHADER_CREATE_INFO* pCreateInfo,
2677 VK_SHADER* pShader);
2678
2679// Pipeline functions
2680
2681VK_RESULT VKAPI vkCreateGraphicsPipeline(
2682 VK_DEVICE device,
2683 const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
2684 VK_PIPELINE* pPipeline);
2685
2686VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(
2687 VK_DEVICE device,
2688 const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
2689 VK_PIPELINE basePipeline,
2690 VK_PIPELINE* pPipeline);
2691
2692VK_RESULT VKAPI vkCreateComputePipeline(
2693 VK_DEVICE device,
2694 const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
2695 VK_PIPELINE* pPipeline);
2696
2697VK_RESULT VKAPI vkStorePipeline(
2698 VK_PIPELINE pipeline,
2699 size_t* pDataSize,
2700 void* pData);
2701
2702VK_RESULT VKAPI vkLoadPipeline(
2703 VK_DEVICE device,
2704 size_t dataSize,
2705 const void* pData,
2706 VK_PIPELINE* pPipeline);
2707
2708VK_RESULT VKAPI vkLoadPipelineDerivative(
2709 VK_DEVICE device,
2710 size_t dataSize,
2711 const void* pData,
2712 VK_PIPELINE basePipeline,
2713 VK_PIPELINE* pPipeline);
2714
2715// Sampler functions
2716
2717VK_RESULT VKAPI vkCreateSampler(
2718 VK_DEVICE device,
2719 const VK_SAMPLER_CREATE_INFO* pCreateInfo,
2720 VK_SAMPLER* pSampler);
2721
2722// Descriptor set functions
2723
2724VK_RESULT VKAPI vkCreateDescriptorSetLayout(
2725 VK_DEVICE device,
2726 const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo,
2727 VK_DESCRIPTOR_SET_LAYOUT* pSetLayout);
2728
2729VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(
2730 VK_DEVICE device,
2731 uint32_t setLayoutArrayCount,
2732 const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray,
2733 VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain);
2734
2735VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(
2736 VK_DEVICE device,
2737 VK_DESCRIPTOR_UPDATE_MODE updateMode);
2738
2739VK_RESULT VKAPI vkEndDescriptorPoolUpdate(
2740 VK_DEVICE device,
2741 VK_CMD_BUFFER cmd);
2742
2743VK_RESULT VKAPI vkCreateDescriptorPool(
2744 VK_DEVICE device,
2745 VK_DESCRIPTOR_POOL_USAGE poolUsage,
2746 uint32_t maxSets,
2747 const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo,
2748 VK_DESCRIPTOR_POOL* pDescriptorPool);
2749
2750VK_RESULT VKAPI vkResetDescriptorPool(
2751 VK_DESCRIPTOR_POOL descriptorPool);
2752
2753VK_RESULT VKAPI vkAllocDescriptorSets(
2754 VK_DESCRIPTOR_POOL descriptorPool,
2755 VK_DESCRIPTOR_SET_USAGE setUsage,
2756 uint32_t count,
2757 const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts,
2758 VK_DESCRIPTOR_SET* pDescriptorSets,
2759 uint32_t* pCount);
2760
2761void VKAPI vkClearDescriptorSets(
2762 VK_DESCRIPTOR_POOL descriptorPool,
2763 uint32_t count,
2764 const VK_DESCRIPTOR_SET* pDescriptorSets);
2765
2766void VKAPI vkUpdateDescriptors(
2767 VK_DESCRIPTOR_SET descriptorSet,
2768 uint32_t updateCount,
2769 const void** ppUpdateArray);
2770
2771// State object functions
2772
2773VK_RESULT VKAPI vkCreateDynamicViewportState(
2774 VK_DEVICE device,
2775 const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
2776 VK_DYNAMIC_VP_STATE_OBJECT* pState);
2777
2778VK_RESULT VKAPI vkCreateDynamicRasterState(
2779 VK_DEVICE device,
2780 const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
2781 VK_DYNAMIC_RS_STATE_OBJECT* pState);
2782
2783VK_RESULT VKAPI vkCreateDynamicColorBlendState(
2784 VK_DEVICE device,
2785 const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
2786 VK_DYNAMIC_CB_STATE_OBJECT* pState);
2787
2788VK_RESULT VKAPI vkCreateDynamicDepthStencilState(
2789 VK_DEVICE device,
2790 const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
2791 VK_DYNAMIC_DS_STATE_OBJECT* pState);
2792
2793// Command buffer functions
2794
2795VK_RESULT VKAPI vkCreateCommandBuffer(
2796 VK_DEVICE device,
2797 const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo,
2798 VK_CMD_BUFFER* pCmdBuffer);
2799
2800VK_RESULT VKAPI vkBeginCommandBuffer(
2801 VK_CMD_BUFFER cmdBuffer,
2802 const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo);
2803
2804VK_RESULT VKAPI vkEndCommandBuffer(
2805 VK_CMD_BUFFER cmdBuffer);
2806
2807VK_RESULT VKAPI vkResetCommandBuffer(
2808 VK_CMD_BUFFER cmdBuffer);
2809
2810// Command buffer building functions
2811
2812void VKAPI vkCmdBindPipeline(
2813 VK_CMD_BUFFER cmdBuffer,
2814 VK_PIPELINE_BIND_POINT pipelineBindPoint,
2815 VK_PIPELINE pipeline);
2816
2817void VKAPI vkCmdBindDynamicStateObject(
2818 VK_CMD_BUFFER cmdBuffer,
2819 VK_STATE_BIND_POINT stateBindPoint,
2820 VK_DYNAMIC_STATE_OBJECT dynamicState);
2821
2822void VKAPI vkCmdBindDescriptorSets(
2823 VK_CMD_BUFFER cmdBuffer,
2824 VK_PIPELINE_BIND_POINT pipelineBindPoint,
2825 VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain,
2826 uint32_t layoutChainSlot,
2827 uint32_t count,
2828 const VK_DESCRIPTOR_SET* pDescriptorSets,
2829 const uint32_t* pUserData);
2830
2831void VKAPI vkCmdBindIndexBuffer(
2832 VK_CMD_BUFFER cmdBuffer,
2833 VK_BUFFER buffer,
2834 VK_GPU_SIZE offset,
2835 VK_INDEX_TYPE indexType);
2836
2837void VKAPI vkCmdBindVertexBuffer(
2838 VK_CMD_BUFFER cmdBuffer,
2839 VK_BUFFER buffer,
2840 VK_GPU_SIZE offset,
2841 uint32_t binding);
2842
2843void VKAPI vkCmdDraw(
2844 VK_CMD_BUFFER cmdBuffer,
2845 uint32_t firstVertex,
2846 uint32_t vertexCount,
2847 uint32_t firstInstance,
2848 uint32_t instanceCount);
2849
2850void VKAPI vkCmdDrawIndexed(
2851 VK_CMD_BUFFER cmdBuffer,
2852 uint32_t firstIndex,
2853 uint32_t indexCount,
2854 int32_t vertexOffset,
2855 uint32_t firstInstance,
2856 uint32_t instanceCount);
2857
2858void VKAPI vkCmdDrawIndirect(
2859 VK_CMD_BUFFER cmdBuffer,
2860 VK_BUFFER buffer,
2861 VK_GPU_SIZE offset,
2862 uint32_t count,
2863 uint32_t stride);
2864
2865void VKAPI vkCmdDrawIndexedIndirect(
2866 VK_CMD_BUFFER cmdBuffer,
2867 VK_BUFFER buffer,
2868 VK_GPU_SIZE offset,
2869 uint32_t count,
2870 uint32_t stride);
2871
2872void VKAPI vkCmdDispatch(
2873 VK_CMD_BUFFER cmdBuffer,
2874 uint32_t x,
2875 uint32_t y,
2876 uint32_t z);
2877
2878void VKAPI vkCmdDispatchIndirect(
2879 VK_CMD_BUFFER cmdBuffer,
2880 VK_BUFFER buffer,
2881 VK_GPU_SIZE offset);
2882
2883void VKAPI vkCmdCopyBuffer(
2884 VK_CMD_BUFFER cmdBuffer,
2885 VK_BUFFER srcBuffer,
2886 VK_BUFFER destBuffer,
2887 uint32_t regionCount,
2888 const VK_BUFFER_COPY* pRegions);
2889
2890void VKAPI vkCmdCopyImage(
2891 VK_CMD_BUFFER cmdBuffer,
2892 VK_IMAGE srcImage,
2893 VK_IMAGE_LAYOUT srcImageLayout,
2894 VK_IMAGE destImage,
2895 VK_IMAGE_LAYOUT destImageLayout,
2896 uint32_t regionCount,
2897 const VK_IMAGE_COPY* pRegions);
2898
2899void VKAPI vkCmdBlitImage(
2900 VK_CMD_BUFFER cmdBuffer,
2901 VK_IMAGE srcImage,
2902 VK_IMAGE_LAYOUT srcImageLayout,
2903 VK_IMAGE destImage,
2904 VK_IMAGE_LAYOUT destImageLayout,
2905 uint32_t regionCount,
2906 const VK_IMAGE_BLIT* pRegions);
2907
2908void VKAPI vkCmdCopyBufferToImage(
2909 VK_CMD_BUFFER cmdBuffer,
2910 VK_BUFFER srcBuffer,
2911 VK_IMAGE destImage,
2912 VK_IMAGE_LAYOUT destImageLayout,
2913 uint32_t regionCount,
2914 const VK_BUFFER_IMAGE_COPY* pRegions);
2915
2916void VKAPI vkCmdCopyImageToBuffer(
2917 VK_CMD_BUFFER cmdBuffer,
2918 VK_IMAGE srcImage,
2919 VK_IMAGE_LAYOUT srcImageLayout,
2920 VK_BUFFER destBuffer,
2921 uint32_t regionCount,
2922 const VK_BUFFER_IMAGE_COPY* pRegions);
2923
2924void VKAPI vkCmdCloneImageData(
2925 VK_CMD_BUFFER cmdBuffer,
2926 VK_IMAGE srcImage,
2927 VK_IMAGE_LAYOUT srcImageLayout,
2928 VK_IMAGE destImage,
2929 VK_IMAGE_LAYOUT destImageLayout);
2930
2931void VKAPI vkCmdUpdateBuffer(
2932 VK_CMD_BUFFER cmdBuffer,
2933 VK_BUFFER destBuffer,
2934 VK_GPU_SIZE destOffset,
2935 VK_GPU_SIZE dataSize,
2936 const uint32_t* pData);
2937
2938void VKAPI vkCmdFillBuffer(
2939 VK_CMD_BUFFER cmdBuffer,
2940 VK_BUFFER destBuffer,
2941 VK_GPU_SIZE destOffset,
2942 VK_GPU_SIZE fillSize,
2943 uint32_t data);
2944
2945void VKAPI vkCmdClearColorImage(
2946 VK_CMD_BUFFER cmdBuffer,
2947 VK_IMAGE image,
2948 VK_IMAGE_LAYOUT imageLayout,
2949 VK_CLEAR_COLOR color,
2950 uint32_t rangeCount,
2951 const VK_IMAGE_SUBRESOURCE_RANGE* pRanges);
2952
2953void VKAPI vkCmdClearDepthStencil(
2954 VK_CMD_BUFFER cmdBuffer,
2955 VK_IMAGE image,
2956 VK_IMAGE_LAYOUT imageLayout,
2957 float depth,
2958 uint32_t stencil,
2959 uint32_t rangeCount,
2960 const VK_IMAGE_SUBRESOURCE_RANGE* pRanges);
2961
2962void VKAPI vkCmdResolveImage(
2963 VK_CMD_BUFFER cmdBuffer,
2964 VK_IMAGE srcImage,
2965 VK_IMAGE_LAYOUT srcImageLayout,
2966 VK_IMAGE destImage,
2967 VK_IMAGE_LAYOUT destImageLayout,
2968 uint32_t rectCount,
2969 const VK_IMAGE_RESOLVE* pRects);
2970
2971void VKAPI vkCmdSetEvent(
2972 VK_CMD_BUFFER cmdBuffer,
2973 VK_EVENT event,
2974 VK_PIPE_EVENT pipeEvent);
2975
2976void VKAPI vkCmdResetEvent(
2977 VK_CMD_BUFFER cmdBuffer,
2978 VK_EVENT event,
2979 VK_PIPE_EVENT pipeEvent);
2980
2981void VKAPI vkCmdWaitEvents(
2982 VK_CMD_BUFFER cmdBuffer,
2983 const VK_EVENT_WAIT_INFO* pWaitInfo);
2984
2985void VKAPI vkCmdPipelineBarrier(
2986 VK_CMD_BUFFER cmdBuffer,
2987 const VK_PIPELINE_BARRIER* pBarrier);
2988
2989void VKAPI vkCmdBeginQuery(
2990 VK_CMD_BUFFER cmdBuffer,
2991 VK_QUERY_POOL queryPool,
2992 uint32_t slot,
2993 VK_FLAGS flags);
2994
2995void VKAPI vkCmdEndQuery(
2996 VK_CMD_BUFFER cmdBuffer,
2997 VK_QUERY_POOL queryPool,
2998 uint32_t slot);
2999
3000void VKAPI vkCmdResetQueryPool(
3001 VK_CMD_BUFFER cmdBuffer,
3002 VK_QUERY_POOL queryPool,
3003 uint32_t startQuery,
3004 uint32_t queryCount);
3005
3006void VKAPI vkCmdWriteTimestamp(
3007 VK_CMD_BUFFER cmdBuffer,
3008 VK_TIMESTAMP_TYPE timestampType,
3009 VK_BUFFER destBuffer,
3010 VK_GPU_SIZE destOffset);
3011
3012void VKAPI vkCmdInitAtomicCounters(
3013 VK_CMD_BUFFER cmdBuffer,
3014 VK_PIPELINE_BIND_POINT pipelineBindPoint,
3015 uint32_t startCounter,
3016 uint32_t counterCount,
3017 const uint32_t* pData);
3018
3019void VKAPI vkCmdLoadAtomicCounters(
3020 VK_CMD_BUFFER cmdBuffer,
3021 VK_PIPELINE_BIND_POINT pipelineBindPoint,
3022 uint32_t startCounter,
3023 uint32_t counterCount,
3024 VK_BUFFER srcBuffer,
3025 VK_GPU_SIZE srcOffset);
3026
3027void VKAPI vkCmdSaveAtomicCounters(
3028 VK_CMD_BUFFER cmdBuffer,
3029 VK_PIPELINE_BIND_POINT pipelineBindPoint,
3030 uint32_t startCounter,
3031 uint32_t counterCount,
3032 VK_BUFFER destBuffer,
3033 VK_GPU_SIZE destOffset);
3034
3035VK_RESULT VKAPI vkCreateFramebuffer(
3036 VK_DEVICE device,
3037 const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo,
3038 VK_FRAMEBUFFER* pFramebuffer);
3039
3040VK_RESULT VKAPI vkCreateRenderPass(
3041 VK_DEVICE device,
3042 const VK_RENDER_PASS_CREATE_INFO* pCreateInfo,
3043 VK_RENDER_PASS* pRenderPass);
3044
3045void VKAPI vkCmdBeginRenderPass(
3046 VK_CMD_BUFFER cmdBuffer,
3047 const VK_RENDER_PASS_BEGIN* pRenderPassBegin);
3048
3049void VKAPI vkCmdEndRenderPass(
3050 VK_CMD_BUFFER cmdBuffer,
3051 VK_RENDER_PASS renderPass);
3052
3053#endif // VK_PROTOTYPES
3054
3055#ifdef __cplusplus
3056} // extern "C"
3057#endif // __cplusplus
3058
3059#endif // __VULKAN_H__
3060
3061/******************************************************************************************
3062
3063 Open Issues + Missing Features
3064 ------------------------------
3065
3066 Here are a few higher level issues that we'd like to fix given time. A feature missing
3067 from this header (or the following list) isn't necessarily an indication that we want
3068 to drop that feature. Only that we either haven't thought of it or haven't had time
3069 to add it yet.
3070
3071 1) Transform Feedback (XFB)
3072
3073 OpenGL supports transform feedback (XFB). That is not included in this header, but
3074 we feel there is likely value in including it.
3075
3076 To incorporate trasnform feedback, we could create a new pipeline stage. This would
3077 be injected into a PSO by including the following in the chain:
3078
3079 typedef struct _VK_XFB_CREATE_INFO
3080 {
3081 VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
3082 const void* pNext; // Pointer to next structure
3083 // More XFB state, if any goes here
3084 } VK_DEPTH_STENCIL_VIEW_CREATE_INFO;
3085
3086 We expect that only the shader-side configuration (via layout qualifiers or their IR
3087 equivalent) is used to configure the data written to each stream. When transform
3088 feedback is part of the pipeline, transform feedback binding would be available
3089 through a new API bind point:
3090
3091 vkCmdBindTransformFeedbackMemoryView(
3092 VK_CMD_BUFFER cmdBuffer,
3093 VK_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS
3094 uint32_t index,
3095 const VK_MEMORY_VIEW_ATTACH_INFO* pMemView);
3096
3097 2) "Bindless" + support for non-bindless hardware.
3098
3099 VK doesn't have bindless textures the way that GL does. It has resource descriptor
3100 sets, or resource tables. Resource tables can be nested and hold references to more
3101 resource tables. They are explicitly sized by the application and have no artificial
3102 upper size limit. An application can still attach as many textures as they want to
3103 a resource descriptor set, and can modify the set asynchronously to GPU work.
3104 Therefore, we can still have "unlimited textures". An application hoping to use
3105 bindless can use an index into a large table of textures and achieve the same effect.
3106
3107 For non-bindless hardware, with fixed (but potentially large) register files for
3108 resource bindings, the table approach should still work if a limited size can be
3109 reported somehow.
3110
3111 3) Clean up some remaining Mantle'isms.
3112
3113 Queue types: It's a bit hand wavey. In Mantle, we have a "universal" queue type that
3114 supports compute and graphics and a "compute" queue that only supports compute. Devices
3115 must support at least one universal queue and DMA queues are an extension. I would like
3116 to do the following (and have attempted to do that here, but am only half done):
3117
3118 a) Separate out the queue capabilities (compute, DMA, graphics) and allow support
3119 for any number of queues with any combination of capabilities each.
3120
3121 b) Allow compute-only or even DMA-only (like video capture or SDI) devices to
3122 be supported.
3123
3124 c) Allow new queue types to be supported by extensions without having to allocate
3125 bits in the bitfield until they're promoted to core.
3126
3127 Terminology: There are still some references to "targets" (render targets) and other
3128 terminology that has been changed from Mantle. Need to do a clean-up pass.
3129
3130 4) The window system interface is an extension in Mantle. We have not tried to fold
3131 any of it into core here. There is no mention of SwapBuffers, presentation, default
3132 framebuffers or anything like that. In the extension, presentation is queued up into
3133 the graphics queue just like any other command.
3134
3135*******************************************************************************************/