9 ** Copyright (c) 2015 The Khronos Group Inc.
11 ** Permission is hereby granted, free of charge, to any person obtaining a
12 ** copy of this software and/or associated documentation files (the
13 ** "Materials"), to deal in the Materials without restriction, including
14 ** without limitation the rights to use, copy, modify, merge, publish,
15 ** distribute, sublicense, and/or sell copies of the Materials, and to
16 ** permit persons to whom the Materials are furnished to do so, subject to
17 ** the following conditions:
19 ** The above copyright notice and this permission notice shall be included
20 ** in all copies or substantial portions of the Materials.
22 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
26 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
27 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
32 #include "vk_platform.h"
34 #define VK_MAKE_VERSION(major, minor, patch) \
35 ((major << 22) | (minor << 12) | patch)
37 // Vulkan API version supported by this file
38 #define VK_API_VERSION VK_MAKE_VERSION(0, 90, 0)
40 #if defined (__cplusplus) && (VK_UINTPTRLEAST64_MAX == UINTPTR_MAX)
41 #define VK_TYPE_SAFE_COMPATIBLE_HANDLES 1
44 #if defined(VK_TYPE_SAFE_COMPATIBLE_HANDLES) && !defined(VK_DISABLE_TYPE_SAFE_HANDLES)
45 #define VK_DEFINE_PTR_HANDLE(_obj) struct _obj##_T { char _dummy; }; typedef _obj##_T* _obj;
46 #define VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj;
48 #define VK_DEFINE_BASE_HANDLE(_obj) VK_DEFINE_PTR_HANDLE(_obj)
49 #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base)
50 #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base)
52 #define VK_DEFINE_BASE_HANDLE(_obj) typedef VkUintPtrLeast64 _obj;
53 #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) typedef uintptr_t _obj;
54 #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) typedef VkUintPtrLeast64 _obj;
58 #define VK_MAX_PHYSICAL_DEVICE_NAME 256
59 #define VK_MAX_EXTENSION_NAME 256
60 #define VK_LOD_CLAMP_NONE MAX_FLOAT
61 #define VK_WHOLE_SIZE UINT64_MAX
64 #define VK_NULL_HANDLE 0
66 VK_DEFINE_BASE_HANDLE(VkObject
)
67 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkInstance
, VkObject
)
68 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkPhysicalDevice
, VkObject
)
69 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkDevice
, VkObject
)
70 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkQueue
, VkObject
)
71 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkCmdBuffer
, VkObject
)
72 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkNonDispatchable
, VkObject
)
73 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDeviceMemory
, VkNonDispatchable
)
74 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBuffer
, VkNonDispatchable
)
75 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBufferView
, VkNonDispatchable
)
76 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImage
, VkNonDispatchable
)
77 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImageView
, VkNonDispatchable
)
78 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkColorAttachmentView
, VkNonDispatchable
)
79 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDepthStencilView
, VkNonDispatchable
)
80 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader
, VkNonDispatchable
)
81 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline
, VkNonDispatchable
)
82 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout
, VkNonDispatchable
)
83 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSampler
, VkNonDispatchable
)
84 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSet
, VkNonDispatchable
)
85 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSetLayout
, VkNonDispatchable
)
86 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorPool
, VkNonDispatchable
)
87 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicStateObject
, VkNonDispatchable
)
88 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicVpState
, VkDynamicStateObject
)
89 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicRsState
, VkDynamicStateObject
)
90 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicCbState
, VkDynamicStateObject
)
91 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicDsState
, VkDynamicStateObject
)
92 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFence
, VkNonDispatchable
)
93 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSemaphore
, VkNonDispatchable
)
94 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkEvent
, VkNonDispatchable
)
95 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkQueryPool
, VkNonDispatchable
)
96 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFramebuffer
, VkNonDispatchable
)
97 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass
, VkNonDispatchable
)
99 // This macro defines INT_MAX in enumerations to force compilers to use 32 bits
100 // to represent them. This may or may not be necessary on some compilers. The
101 // option to compile it out may allow compilers that warn about missing enumerants
102 // in switch statements to be silenced.
103 // Using this macro is not needed for flag bit enums because those aren't used
104 // as storage type anywhere.
105 #define VK_MAX_ENUM(Prefix) VK_##Prefix##_MAX_ENUM = 0x7FFFFFFF
107 // This macro defines the BEGIN_RANGE, END_RANGE, NUM, and MAX_ENUM constants for
109 #define VK_ENUM_RANGE(Prefix, First, Last) \
110 VK_##Prefix##_BEGIN_RANGE = VK_##Prefix##_##First, \
111 VK_##Prefix##_END_RANGE = VK_##Prefix##_##Last, \
112 VK_NUM_##Prefix = (VK_##Prefix##_END_RANGE - VK_##Prefix##_BEGIN_RANGE + 1), \
115 // This is a helper macro to define the value of flag bit enum values.
116 #define VK_BIT(bit) (1 << (bit))
118 // ------------------------------------------------------------------------------------------------
121 typedef enum VkImageLayout_
123 VK_IMAGE_LAYOUT_UNDEFINED
= 0x00000000, // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
124 VK_IMAGE_LAYOUT_GENERAL
= 0x00000001, // General layout when image can be used for any kind of access
125 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
= 0x00000002, // Optimal layout when image is only used for color attachment read/write
126 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
= 0x00000003, // Optimal layout when image is only used for depth/stencil attachment read/write
127 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
= 0x00000004, // Optimal layout when image is used for read only depth/stencil attachment and shader access
128 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
= 0x00000005, // Optimal layout when image is used for read only shader access
129 VK_IMAGE_LAYOUT_CLEAR_OPTIMAL
= 0x00000006, // Optimal layout when image is used only for clear operations
130 VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL
= 0x00000007, // Optimal layout when image is used only as source of transfer operations
131 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL
= 0x00000008, // Optimal layout when image is used only as destination of transfer operations
133 VK_ENUM_RANGE(IMAGE_LAYOUT
, UNDEFINED
, TRANSFER_DESTINATION_OPTIMAL
)
136 typedef enum VkPipeEvent_
138 VK_PIPE_EVENT_TOP_OF_PIPE
= 0x00000001, // Set event before the device starts processing subsequent command
139 VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE
= 0x00000002, // Set event when all pending vertex processing is complete
140 VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE
= 0x00000003, // Set event when all pending fragment shader executions are complete, within each fragment location
141 VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE
= 0x00000004, // Set event when all pending fragment shader executions are complete
142 VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE
= 0x00000005, // Set event when all pending graphics operations are complete
143 VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE
= 0x00000006, // Set event when all pending compute operations are complete
144 VK_PIPE_EVENT_TRANSFER_COMPLETE
= 0x00000007, // Set event when all pending transfer operations are complete
145 VK_PIPE_EVENT_COMMANDS_COMPLETE
= 0x00000008, // Set event when all pending work is complete
147 VK_ENUM_RANGE(PIPE_EVENT
, TOP_OF_PIPE
, COMMANDS_COMPLETE
)
150 typedef enum VkWaitEvent_
152 VK_WAIT_EVENT_TOP_OF_PIPE
= 0x00000001, // Wait event before the device starts processing subsequent commands
153 VK_WAIT_EVENT_BEFORE_RASTERIZATION
= 0x00000002, // Wait event before rasterizing subsequent primitives
155 VK_ENUM_RANGE(WAIT_EVENT
, TOP_OF_PIPE
, BEFORE_RASTERIZATION
)
158 typedef enum VkAttachmentLoadOp_
160 VK_ATTACHMENT_LOAD_OP_LOAD
= 0x00000000,
161 VK_ATTACHMENT_LOAD_OP_CLEAR
= 0x00000001,
162 VK_ATTACHMENT_LOAD_OP_DONT_CARE
= 0x00000002,
164 VK_ENUM_RANGE(ATTACHMENT_LOAD_OP
, LOAD
, DONT_CARE
)
165 } VkAttachmentLoadOp
;
167 typedef enum VkAttachmentStoreOp_
169 VK_ATTACHMENT_STORE_OP_STORE
= 0x00000000,
170 VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA
= 0x00000001,
171 VK_ATTACHMENT_STORE_OP_DONT_CARE
= 0x00000002,
173 VK_ENUM_RANGE(ATTACHMENT_STORE_OP
, STORE
, DONT_CARE
)
174 } VkAttachmentStoreOp
;
176 typedef enum VkImageType_
178 VK_IMAGE_TYPE_1D
= 0x00000000,
179 VK_IMAGE_TYPE_2D
= 0x00000001,
180 VK_IMAGE_TYPE_3D
= 0x00000002,
182 VK_ENUM_RANGE(IMAGE_TYPE
, 1D
, 3D
)
185 typedef enum VkImageTiling_
187 VK_IMAGE_TILING_LINEAR
= 0x00000000,
188 VK_IMAGE_TILING_OPTIMAL
= 0x00000001,
190 VK_ENUM_RANGE(IMAGE_TILING
, LINEAR
, OPTIMAL
)
193 typedef enum VkImageViewType_
195 VK_IMAGE_VIEW_TYPE_1D
= 0x00000000,
196 VK_IMAGE_VIEW_TYPE_2D
= 0x00000001,
197 VK_IMAGE_VIEW_TYPE_3D
= 0x00000002,
198 VK_IMAGE_VIEW_TYPE_CUBE
= 0x00000003,
200 VK_ENUM_RANGE(IMAGE_VIEW_TYPE
, 1D
, CUBE
)
203 typedef enum VkImageAspect_
205 VK_IMAGE_ASPECT_COLOR
= 0x00000000,
206 VK_IMAGE_ASPECT_DEPTH
= 0x00000001,
207 VK_IMAGE_ASPECT_STENCIL
= 0x00000002,
209 VK_ENUM_RANGE(IMAGE_ASPECT
, COLOR
, STENCIL
)
212 typedef enum VkBufferViewType_
214 VK_BUFFER_VIEW_TYPE_RAW
= 0x00000000, // Raw buffer without special structure (UBO, SSBO)
215 VK_BUFFER_VIEW_TYPE_FORMATTED
= 0x00000001, // Buffer with format (TBO, IBO)
217 VK_ENUM_RANGE(BUFFER_VIEW_TYPE
, RAW
, FORMATTED
)
220 typedef enum VkChannelSwizzle_
222 VK_CHANNEL_SWIZZLE_ZERO
= 0x00000000,
223 VK_CHANNEL_SWIZZLE_ONE
= 0x00000001,
224 VK_CHANNEL_SWIZZLE_R
= 0x00000002,
225 VK_CHANNEL_SWIZZLE_G
= 0x00000003,
226 VK_CHANNEL_SWIZZLE_B
= 0x00000004,
227 VK_CHANNEL_SWIZZLE_A
= 0x00000005,
229 VK_ENUM_RANGE(CHANNEL_SWIZZLE
, ZERO
, A
)
232 typedef enum VkDescriptorType_
234 VK_DESCRIPTOR_TYPE_SAMPLER
= 0x00000000,
235 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
= 0x00000001,
236 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
= 0x00000002,
237 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
= 0x00000003,
238 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER
= 0x00000004,
239 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
= 0x00000005,
240 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
= 0x00000006,
241 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
= 0x00000007,
242 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
= 0x00000008,
243 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
= 0x00000009,
245 VK_ENUM_RANGE(DESCRIPTOR_TYPE
, SAMPLER
, STORAGE_BUFFER_DYNAMIC
)
248 typedef enum VkDescriptorPoolUsage_
250 VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT
= 0x00000000,
251 VK_DESCRIPTOR_POOL_USAGE_DYNAMIC
= 0x00000001,
253 VK_ENUM_RANGE(DESCRIPTOR_POOL_USAGE
, ONE_SHOT
, DYNAMIC
)
254 } VkDescriptorPoolUsage
;
256 typedef enum VkDescriptorUpdateMode_
258 VK_DESCRIPTOR_UPDATE_MODE_COPY
= 0x00000000,
259 VK_DESCRIPTOR_UPDATE_MODE_FASTEST
= 0x00000001,
261 VK_ENUM_RANGE(DESCRIPTOR_UPDATE_MODE
, COPY
, FASTEST
)
262 } VkDescriptorUpdateMode
;
264 typedef enum VkDescriptorSetUsage_
266 VK_DESCRIPTOR_SET_USAGE_ONE_SHOT
= 0x00000000,
267 VK_DESCRIPTOR_SET_USAGE_STATIC
= 0x00000001,
269 VK_ENUM_RANGE(DESCRIPTOR_SET_USAGE
, ONE_SHOT
, STATIC
)
270 } VkDescriptorSetUsage
;
272 typedef enum VkQueryType_
274 VK_QUERY_TYPE_OCCLUSION
= 0x00000000,
275 VK_QUERY_TYPE_PIPELINE_STATISTICS
= 0x00000001, // Optional
277 VK_ENUM_RANGE(QUERY_TYPE
, OCCLUSION
, PIPELINE_STATISTICS
)
280 typedef enum VkTimestampType_
282 VK_TIMESTAMP_TYPE_TOP
= 0x00000000,
283 VK_TIMESTAMP_TYPE_BOTTOM
= 0x00000001,
285 VK_ENUM_RANGE(TIMESTAMP_TYPE
, TOP
, BOTTOM
)
288 typedef enum VkBorderColor_
290 VK_BORDER_COLOR_OPAQUE_WHITE
= 0x00000000,
291 VK_BORDER_COLOR_TRANSPARENT_BLACK
= 0x00000001,
292 VK_BORDER_COLOR_OPAQUE_BLACK
= 0x00000002,
294 VK_ENUM_RANGE(BORDER_COLOR
, OPAQUE_WHITE
, OPAQUE_BLACK
)
297 typedef enum VkPipelineBindPoint_
299 VK_PIPELINE_BIND_POINT_COMPUTE
= 0x00000000,
300 VK_PIPELINE_BIND_POINT_GRAPHICS
= 0x00000001,
302 VK_ENUM_RANGE(PIPELINE_BIND_POINT
, COMPUTE
, GRAPHICS
)
303 } VkPipelineBindPoint
;
305 typedef enum VkStateBindPoint_
307 VK_STATE_BIND_POINT_VIEWPORT
= 0x00000000,
308 VK_STATE_BIND_POINT_RASTER
= 0x00000001,
309 VK_STATE_BIND_POINT_COLOR_BLEND
= 0x00000002,
310 VK_STATE_BIND_POINT_DEPTH_STENCIL
= 0x00000003,
312 VK_ENUM_RANGE(STATE_BIND_POINT
, VIEWPORT
, DEPTH_STENCIL
)
315 typedef enum VkPrimitiveTopology_
317 VK_PRIMITIVE_TOPOLOGY_POINT_LIST
= 0x00000000,
318 VK_PRIMITIVE_TOPOLOGY_LINE_LIST
= 0x00000001,
319 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP
= 0x00000002,
320 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
= 0x00000003,
321 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
= 0x00000004,
322 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN
= 0x00000005,
323 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ
= 0x00000006,
324 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ
= 0x00000007,
325 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ
= 0x00000008,
326 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ
= 0x00000009,
327 VK_PRIMITIVE_TOPOLOGY_PATCH
= 0x0000000a,
329 VK_ENUM_RANGE(PRIMITIVE_TOPOLOGY
, POINT_LIST
, PATCH
)
330 } VkPrimitiveTopology
;
332 typedef enum VkIndexType_
334 VK_INDEX_TYPE_UINT8
= 0x00000000,
335 VK_INDEX_TYPE_UINT16
= 0x00000001,
336 VK_INDEX_TYPE_UINT32
= 0x00000002,
338 VK_ENUM_RANGE(INDEX_TYPE
, UINT8
, UINT32
)
341 typedef enum VkTexFilter_
343 VK_TEX_FILTER_NEAREST
= 0x00000000,
344 VK_TEX_FILTER_LINEAR
= 0x00000001,
346 VK_ENUM_RANGE(TEX_FILTER
, NEAREST
, LINEAR
)
349 typedef enum VkTexMipmapMode_
351 VK_TEX_MIPMAP_MODE_BASE
= 0x00000000, // Always choose base level
352 VK_TEX_MIPMAP_MODE_NEAREST
= 0x00000001, // Choose nearest mip level
353 VK_TEX_MIPMAP_MODE_LINEAR
= 0x00000002, // Linear filter between mip levels
355 VK_ENUM_RANGE(TEX_MIPMAP_MODE
, BASE
, LINEAR
)
358 typedef enum VkTexAddress_
360 VK_TEX_ADDRESS_WRAP
= 0x00000000,
361 VK_TEX_ADDRESS_MIRROR
= 0x00000001,
362 VK_TEX_ADDRESS_CLAMP
= 0x00000002,
363 VK_TEX_ADDRESS_MIRROR_ONCE
= 0x00000003,
364 VK_TEX_ADDRESS_CLAMP_BORDER
= 0x00000004,
366 VK_ENUM_RANGE(TEX_ADDRESS
, WRAP
, CLAMP_BORDER
)
369 typedef enum VkCompareOp_
371 VK_COMPARE_OP_NEVER
= 0x00000000,
372 VK_COMPARE_OP_LESS
= 0x00000001,
373 VK_COMPARE_OP_EQUAL
= 0x00000002,
374 VK_COMPARE_OP_LESS_EQUAL
= 0x00000003,
375 VK_COMPARE_OP_GREATER
= 0x00000004,
376 VK_COMPARE_OP_NOT_EQUAL
= 0x00000005,
377 VK_COMPARE_OP_GREATER_EQUAL
= 0x00000006,
378 VK_COMPARE_OP_ALWAYS
= 0x00000007,
380 VK_ENUM_RANGE(COMPARE_OP
, NEVER
, ALWAYS
)
383 typedef enum VkFillMode_
385 VK_FILL_MODE_POINTS
= 0x00000000,
386 VK_FILL_MODE_WIREFRAME
= 0x00000001,
387 VK_FILL_MODE_SOLID
= 0x00000002,
389 VK_ENUM_RANGE(FILL_MODE
, POINTS
, SOLID
)
392 typedef enum VkCullMode_
394 VK_CULL_MODE_NONE
= 0x00000000,
395 VK_CULL_MODE_FRONT
= 0x00000001,
396 VK_CULL_MODE_BACK
= 0x00000002,
397 VK_CULL_MODE_FRONT_AND_BACK
= 0x00000003,
399 VK_ENUM_RANGE(CULL_MODE
, NONE
, FRONT_AND_BACK
)
402 typedef enum VkFrontFace_
404 VK_FRONT_FACE_CCW
= 0x00000000,
405 VK_FRONT_FACE_CW
= 0x00000001,
407 VK_ENUM_RANGE(FRONT_FACE
, CCW
, CW
)
410 typedef enum VkProvokingVertex_
412 VK_PROVOKING_VERTEX_FIRST
= 0x00000000,
413 VK_PROVOKING_VERTEX_LAST
= 0x00000001,
415 VK_ENUM_RANGE(PROVOKING_VERTEX
, FIRST
, LAST
)
418 typedef enum VkCoordinateOrigin_
420 VK_COORDINATE_ORIGIN_UPPER_LEFT
= 0x00000000,
421 VK_COORDINATE_ORIGIN_LOWER_LEFT
= 0x00000001,
423 VK_ENUM_RANGE(COORDINATE_ORIGIN
, UPPER_LEFT
, LOWER_LEFT
)
424 } VkCoordinateOrigin
;
426 typedef enum VkDepthMode_
428 VK_DEPTH_MODE_ZERO_TO_ONE
= 0x00000000,
429 VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE
= 0x00000001,
431 VK_ENUM_RANGE(DEPTH_MODE
, ZERO_TO_ONE
, NEGATIVE_ONE_TO_ONE
)
434 typedef enum VkBlend_
436 VK_BLEND_ZERO
= 0x00000000,
437 VK_BLEND_ONE
= 0x00000001,
438 VK_BLEND_SRC_COLOR
= 0x00000002,
439 VK_BLEND_ONE_MINUS_SRC_COLOR
= 0x00000003,
440 VK_BLEND_DEST_COLOR
= 0x00000004,
441 VK_BLEND_ONE_MINUS_DEST_COLOR
= 0x00000005,
442 VK_BLEND_SRC_ALPHA
= 0x00000006,
443 VK_BLEND_ONE_MINUS_SRC_ALPHA
= 0x00000007,
444 VK_BLEND_DEST_ALPHA
= 0x00000008,
445 VK_BLEND_ONE_MINUS_DEST_ALPHA
= 0x00000009,
446 VK_BLEND_CONSTANT_COLOR
= 0x0000000a,
447 VK_BLEND_ONE_MINUS_CONSTANT_COLOR
= 0x0000000b,
448 VK_BLEND_CONSTANT_ALPHA
= 0x0000000c,
449 VK_BLEND_ONE_MINUS_CONSTANT_ALPHA
= 0x0000000d,
450 VK_BLEND_SRC_ALPHA_SATURATE
= 0x0000000e,
451 VK_BLEND_SRC1_COLOR
= 0x0000000f,
452 VK_BLEND_ONE_MINUS_SRC1_COLOR
= 0x00000010,
453 VK_BLEND_SRC1_ALPHA
= 0x00000011,
454 VK_BLEND_ONE_MINUS_SRC1_ALPHA
= 0x00000012,
456 VK_ENUM_RANGE(BLEND
, ZERO
, ONE_MINUS_SRC1_ALPHA
)
459 typedef enum VkBlendOp_
461 VK_BLEND_OP_ADD
= 0x00000000,
462 VK_BLEND_OP_SUBTRACT
= 0x00000001,
463 VK_BLEND_OP_REVERSE_SUBTRACT
= 0x00000002,
464 VK_BLEND_OP_MIN
= 0x00000003,
465 VK_BLEND_OP_MAX
= 0x00000004,
467 VK_ENUM_RANGE(BLEND_OP
, ADD
, MAX
)
470 typedef enum VkStencilOp_
472 VK_STENCIL_OP_KEEP
= 0x00000000,
473 VK_STENCIL_OP_ZERO
= 0x00000001,
474 VK_STENCIL_OP_REPLACE
= 0x00000002,
475 VK_STENCIL_OP_INC_CLAMP
= 0x00000003,
476 VK_STENCIL_OP_DEC_CLAMP
= 0x00000004,
477 VK_STENCIL_OP_INVERT
= 0x00000005,
478 VK_STENCIL_OP_INC_WRAP
= 0x00000006,
479 VK_STENCIL_OP_DEC_WRAP
= 0x00000007,
481 VK_ENUM_RANGE(STENCIL_OP
, KEEP
, DEC_WRAP
)
484 typedef enum VkLogicOp_
486 VK_LOGIC_OP_COPY
= 0x00000000,
487 VK_LOGIC_OP_CLEAR
= 0x00000001,
488 VK_LOGIC_OP_AND
= 0x00000002,
489 VK_LOGIC_OP_AND_REVERSE
= 0x00000003,
490 VK_LOGIC_OP_AND_INVERTED
= 0x00000004,
491 VK_LOGIC_OP_NOOP
= 0x00000005,
492 VK_LOGIC_OP_XOR
= 0x00000006,
493 VK_LOGIC_OP_OR
= 0x00000007,
494 VK_LOGIC_OP_NOR
= 0x00000008,
495 VK_LOGIC_OP_EQUIV
= 0x00000009,
496 VK_LOGIC_OP_INVERT
= 0x0000000a,
497 VK_LOGIC_OP_OR_REVERSE
= 0x0000000b,
498 VK_LOGIC_OP_COPY_INVERTED
= 0x0000000c,
499 VK_LOGIC_OP_OR_INVERTED
= 0x0000000d,
500 VK_LOGIC_OP_NAND
= 0x0000000e,
501 VK_LOGIC_OP_SET
= 0x0000000f,
503 VK_ENUM_RANGE(LOGIC_OP
, COPY
, SET
)
506 typedef enum VkSystemAllocType_
508 VK_SYSTEM_ALLOC_TYPE_API_OBJECT
= 0x00000000,
509 VK_SYSTEM_ALLOC_TYPE_INTERNAL
= 0x00000001,
510 VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP
= 0x00000002,
511 VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER
= 0x00000003,
512 VK_SYSTEM_ALLOC_TYPE_DEBUG
= 0x00000004,
514 VK_ENUM_RANGE(SYSTEM_ALLOC_TYPE
, API_OBJECT
, DEBUG
)
517 typedef enum VkPhysicalDeviceType_
519 VK_PHYSICAL_DEVICE_TYPE_OTHER
= 0x00000000,
520 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU
= 0x00000001,
521 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU
= 0x00000002,
522 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU
= 0x00000003,
523 VK_PHYSICAL_DEVICE_TYPE_CPU
= 0x00000004,
525 VK_ENUM_RANGE(PHYSICAL_DEVICE_TYPE
, OTHER
, CPU
)
526 } VkPhysicalDeviceType
;
528 typedef enum VkPhysicalDeviceInfoType_
530 // Info type for vkGetPhysicalDeviceInfo()
531 VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES
= 0x00000000,
532 VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE
= 0x00000001,
533 VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES
= 0x00000002,
534 VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES
= 0x00000003,
536 VK_ENUM_RANGE(PHYSICAL_DEVICE_INFO_TYPE
, PROPERTIES
, MEMORY_PROPERTIES
)
537 } VkPhysicalDeviceInfoType
;
539 typedef enum VkExtensionInfoType_
541 // Info type for vkGetGlobalExtensionInfo() and vkGetPhysicalDeviceExtensionInfo()
542 VK_EXTENSION_INFO_TYPE_COUNT
= 0x00000000,
543 VK_EXTENSION_INFO_TYPE_PROPERTIES
= 0x00000001,
545 VK_ENUM_RANGE(EXTENSION_INFO_TYPE
, COUNT
, PROPERTIES
)
546 } VkExtensionInfoType
;
548 typedef enum VkFormatInfoType_
550 // Info type for vkGetFormatInfo()
551 VK_FORMAT_INFO_TYPE_PROPERTIES
= 0x00000000,
553 VK_ENUM_RANGE(FORMAT_INFO_TYPE
, PROPERTIES
, PROPERTIES
)
556 typedef enum VkSubresourceInfoType_
558 // Info type for vkGetImageSubresourceInfo()
559 VK_SUBRESOURCE_INFO_TYPE_LAYOUT
= 0x00000000,
561 VK_ENUM_RANGE(SUBRESOURCE_INFO_TYPE
, LAYOUT
, LAYOUT
)
562 } VkSubresourceInfoType
;
564 typedef enum VkObjectInfoType_
566 // Info type for vkGetObjectInfo()
567 VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT
= 0x00000000,
568 VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS
= 0x00000001,
570 VK_ENUM_RANGE(OBJECT_INFO_TYPE
, MEMORY_ALLOCATION_COUNT
, MEMORY_REQUIREMENTS
)
573 typedef enum VkVertexInputStepRate_
575 VK_VERTEX_INPUT_STEP_RATE_VERTEX
= 0x0,
576 VK_VERTEX_INPUT_STEP_RATE_INSTANCE
= 0x1,
577 VK_VERTEX_INPUT_STEP_RATE_DRAW
= 0x2, //Optional
579 VK_ENUM_RANGE(VERTEX_INPUT_STEP_RATE
, VERTEX
, DRAW
)
580 } VkVertexInputStepRate
;
582 // Vulkan format definitions
583 typedef enum VkFormat_
585 VK_FORMAT_UNDEFINED
= 0x00000000,
586 VK_FORMAT_R4G4_UNORM
= 0x00000001,
587 VK_FORMAT_R4G4_USCALED
= 0x00000002,
588 VK_FORMAT_R4G4B4A4_UNORM
= 0x00000003,
589 VK_FORMAT_R4G4B4A4_USCALED
= 0x00000004,
590 VK_FORMAT_R5G6B5_UNORM
= 0x00000005,
591 VK_FORMAT_R5G6B5_USCALED
= 0x00000006,
592 VK_FORMAT_R5G5B5A1_UNORM
= 0x00000007,
593 VK_FORMAT_R5G5B5A1_USCALED
= 0x00000008,
594 VK_FORMAT_R8_UNORM
= 0x00000009,
595 VK_FORMAT_R8_SNORM
= 0x0000000A,
596 VK_FORMAT_R8_USCALED
= 0x0000000B,
597 VK_FORMAT_R8_SSCALED
= 0x0000000C,
598 VK_FORMAT_R8_UINT
= 0x0000000D,
599 VK_FORMAT_R8_SINT
= 0x0000000E,
600 VK_FORMAT_R8_SRGB
= 0x0000000F,
601 VK_FORMAT_R8G8_UNORM
= 0x00000010,
602 VK_FORMAT_R8G8_SNORM
= 0x00000011,
603 VK_FORMAT_R8G8_USCALED
= 0x00000012,
604 VK_FORMAT_R8G8_SSCALED
= 0x00000013,
605 VK_FORMAT_R8G8_UINT
= 0x00000014,
606 VK_FORMAT_R8G8_SINT
= 0x00000015,
607 VK_FORMAT_R8G8_SRGB
= 0x00000016,
608 VK_FORMAT_R8G8B8_UNORM
= 0x00000017,
609 VK_FORMAT_R8G8B8_SNORM
= 0x00000018,
610 VK_FORMAT_R8G8B8_USCALED
= 0x00000019,
611 VK_FORMAT_R8G8B8_SSCALED
= 0x0000001A,
612 VK_FORMAT_R8G8B8_UINT
= 0x0000001B,
613 VK_FORMAT_R8G8B8_SINT
= 0x0000001C,
614 VK_FORMAT_R8G8B8_SRGB
= 0x0000001D,
615 VK_FORMAT_R8G8B8A8_UNORM
= 0x0000001E,
616 VK_FORMAT_R8G8B8A8_SNORM
= 0x0000001F,
617 VK_FORMAT_R8G8B8A8_USCALED
= 0x00000020,
618 VK_FORMAT_R8G8B8A8_SSCALED
= 0x00000021,
619 VK_FORMAT_R8G8B8A8_UINT
= 0x00000022,
620 VK_FORMAT_R8G8B8A8_SINT
= 0x00000023,
621 VK_FORMAT_R8G8B8A8_SRGB
= 0x00000024,
622 VK_FORMAT_R10G10B10A2_UNORM
= 0x00000025,
623 VK_FORMAT_R10G10B10A2_SNORM
= 0x00000026,
624 VK_FORMAT_R10G10B10A2_USCALED
= 0x00000027,
625 VK_FORMAT_R10G10B10A2_SSCALED
= 0x00000028,
626 VK_FORMAT_R10G10B10A2_UINT
= 0x00000029,
627 VK_FORMAT_R10G10B10A2_SINT
= 0x0000002A,
628 VK_FORMAT_R16_UNORM
= 0x0000002B,
629 VK_FORMAT_R16_SNORM
= 0x0000002C,
630 VK_FORMAT_R16_USCALED
= 0x0000002D,
631 VK_FORMAT_R16_SSCALED
= 0x0000002E,
632 VK_FORMAT_R16_UINT
= 0x0000002F,
633 VK_FORMAT_R16_SINT
= 0x00000030,
634 VK_FORMAT_R16_SFLOAT
= 0x00000031,
635 VK_FORMAT_R16G16_UNORM
= 0x00000032,
636 VK_FORMAT_R16G16_SNORM
= 0x00000033,
637 VK_FORMAT_R16G16_USCALED
= 0x00000034,
638 VK_FORMAT_R16G16_SSCALED
= 0x00000035,
639 VK_FORMAT_R16G16_UINT
= 0x00000036,
640 VK_FORMAT_R16G16_SINT
= 0x00000037,
641 VK_FORMAT_R16G16_SFLOAT
= 0x00000038,
642 VK_FORMAT_R16G16B16_UNORM
= 0x00000039,
643 VK_FORMAT_R16G16B16_SNORM
= 0x0000003A,
644 VK_FORMAT_R16G16B16_USCALED
= 0x0000003B,
645 VK_FORMAT_R16G16B16_SSCALED
= 0x0000003C,
646 VK_FORMAT_R16G16B16_UINT
= 0x0000003D,
647 VK_FORMAT_R16G16B16_SINT
= 0x0000003E,
648 VK_FORMAT_R16G16B16_SFLOAT
= 0x0000003F,
649 VK_FORMAT_R16G16B16A16_UNORM
= 0x00000040,
650 VK_FORMAT_R16G16B16A16_SNORM
= 0x00000041,
651 VK_FORMAT_R16G16B16A16_USCALED
= 0x00000042,
652 VK_FORMAT_R16G16B16A16_SSCALED
= 0x00000043,
653 VK_FORMAT_R16G16B16A16_UINT
= 0x00000044,
654 VK_FORMAT_R16G16B16A16_SINT
= 0x00000045,
655 VK_FORMAT_R16G16B16A16_SFLOAT
= 0x00000046,
656 VK_FORMAT_R32_UINT
= 0x00000047,
657 VK_FORMAT_R32_SINT
= 0x00000048,
658 VK_FORMAT_R32_SFLOAT
= 0x00000049,
659 VK_FORMAT_R32G32_UINT
= 0x0000004A,
660 VK_FORMAT_R32G32_SINT
= 0x0000004B,
661 VK_FORMAT_R32G32_SFLOAT
= 0x0000004C,
662 VK_FORMAT_R32G32B32_UINT
= 0x0000004D,
663 VK_FORMAT_R32G32B32_SINT
= 0x0000004E,
664 VK_FORMAT_R32G32B32_SFLOAT
= 0x0000004F,
665 VK_FORMAT_R32G32B32A32_UINT
= 0x00000050,
666 VK_FORMAT_R32G32B32A32_SINT
= 0x00000051,
667 VK_FORMAT_R32G32B32A32_SFLOAT
= 0x00000052,
668 VK_FORMAT_R64_SFLOAT
= 0x00000053,
669 VK_FORMAT_R64G64_SFLOAT
= 0x00000054,
670 VK_FORMAT_R64G64B64_SFLOAT
= 0x00000055,
671 VK_FORMAT_R64G64B64A64_SFLOAT
= 0x00000056,
672 VK_FORMAT_R11G11B10_UFLOAT
= 0x00000057,
673 VK_FORMAT_R9G9B9E5_UFLOAT
= 0x00000058,
674 VK_FORMAT_D16_UNORM
= 0x00000059,
675 VK_FORMAT_D24_UNORM
= 0x0000005A,
676 VK_FORMAT_D32_SFLOAT
= 0x0000005B,
677 VK_FORMAT_S8_UINT
= 0x0000005C,
678 VK_FORMAT_D16_UNORM_S8_UINT
= 0x0000005D,
679 VK_FORMAT_D24_UNORM_S8_UINT
= 0x0000005E,
680 VK_FORMAT_D32_SFLOAT_S8_UINT
= 0x0000005F,
681 VK_FORMAT_BC1_RGB_UNORM
= 0x00000060,
682 VK_FORMAT_BC1_RGB_SRGB
= 0x00000061,
683 VK_FORMAT_BC1_RGBA_UNORM
= 0x00000062,
684 VK_FORMAT_BC1_RGBA_SRGB
= 0x00000063,
685 VK_FORMAT_BC2_UNORM
= 0x00000064,
686 VK_FORMAT_BC2_SRGB
= 0x00000065,
687 VK_FORMAT_BC3_UNORM
= 0x00000066,
688 VK_FORMAT_BC3_SRGB
= 0x00000067,
689 VK_FORMAT_BC4_UNORM
= 0x00000068,
690 VK_FORMAT_BC4_SNORM
= 0x00000069,
691 VK_FORMAT_BC5_UNORM
= 0x0000006A,
692 VK_FORMAT_BC5_SNORM
= 0x0000006B,
693 VK_FORMAT_BC6H_UFLOAT
= 0x0000006C,
694 VK_FORMAT_BC6H_SFLOAT
= 0x0000006D,
695 VK_FORMAT_BC7_UNORM
= 0x0000006E,
696 VK_FORMAT_BC7_SRGB
= 0x0000006F,
697 VK_FORMAT_ETC2_R8G8B8_UNORM
= 0x00000070,
698 VK_FORMAT_ETC2_R8G8B8_SRGB
= 0x00000071,
699 VK_FORMAT_ETC2_R8G8B8A1_UNORM
= 0x00000072,
700 VK_FORMAT_ETC2_R8G8B8A1_SRGB
= 0x00000073,
701 VK_FORMAT_ETC2_R8G8B8A8_UNORM
= 0x00000074,
702 VK_FORMAT_ETC2_R8G8B8A8_SRGB
= 0x00000075,
703 VK_FORMAT_EAC_R11_UNORM
= 0x00000076,
704 VK_FORMAT_EAC_R11_SNORM
= 0x00000077,
705 VK_FORMAT_EAC_R11G11_UNORM
= 0x00000078,
706 VK_FORMAT_EAC_R11G11_SNORM
= 0x00000079,
707 VK_FORMAT_ASTC_4x4_UNORM
= 0x0000007A,
708 VK_FORMAT_ASTC_4x4_SRGB
= 0x0000007B,
709 VK_FORMAT_ASTC_5x4_UNORM
= 0x0000007C,
710 VK_FORMAT_ASTC_5x4_SRGB
= 0x0000007D,
711 VK_FORMAT_ASTC_5x5_UNORM
= 0x0000007E,
712 VK_FORMAT_ASTC_5x5_SRGB
= 0x0000007F,
713 VK_FORMAT_ASTC_6x5_UNORM
= 0x00000080,
714 VK_FORMAT_ASTC_6x5_SRGB
= 0x00000081,
715 VK_FORMAT_ASTC_6x6_UNORM
= 0x00000082,
716 VK_FORMAT_ASTC_6x6_SRGB
= 0x00000083,
717 VK_FORMAT_ASTC_8x5_UNORM
= 0x00000084,
718 VK_FORMAT_ASTC_8x5_SRGB
= 0x00000085,
719 VK_FORMAT_ASTC_8x6_UNORM
= 0x00000086,
720 VK_FORMAT_ASTC_8x6_SRGB
= 0x00000087,
721 VK_FORMAT_ASTC_8x8_UNORM
= 0x00000088,
722 VK_FORMAT_ASTC_8x8_SRGB
= 0x00000089,
723 VK_FORMAT_ASTC_10x5_UNORM
= 0x0000008A,
724 VK_FORMAT_ASTC_10x5_SRGB
= 0x0000008B,
725 VK_FORMAT_ASTC_10x6_UNORM
= 0x0000008C,
726 VK_FORMAT_ASTC_10x6_SRGB
= 0x0000008D,
727 VK_FORMAT_ASTC_10x8_UNORM
= 0x0000008E,
728 VK_FORMAT_ASTC_10x8_SRGB
= 0x0000008F,
729 VK_FORMAT_ASTC_10x10_UNORM
= 0x00000090,
730 VK_FORMAT_ASTC_10x10_SRGB
= 0x00000091,
731 VK_FORMAT_ASTC_12x10_UNORM
= 0x00000092,
732 VK_FORMAT_ASTC_12x10_SRGB
= 0x00000093,
733 VK_FORMAT_ASTC_12x12_UNORM
= 0x00000094,
734 VK_FORMAT_ASTC_12x12_SRGB
= 0x00000095,
735 VK_FORMAT_B4G4R4A4_UNORM
= 0x00000096,
736 VK_FORMAT_B5G5R5A1_UNORM
= 0x00000097,
737 VK_FORMAT_B5G6R5_UNORM
= 0x00000098,
738 VK_FORMAT_B5G6R5_USCALED
= 0x00000099,
739 VK_FORMAT_B8G8R8_UNORM
= 0x0000009A,
740 VK_FORMAT_B8G8R8_SNORM
= 0x0000009B,
741 VK_FORMAT_B8G8R8_USCALED
= 0x0000009C,
742 VK_FORMAT_B8G8R8_SSCALED
= 0x0000009D,
743 VK_FORMAT_B8G8R8_UINT
= 0x0000009E,
744 VK_FORMAT_B8G8R8_SINT
= 0x0000009F,
745 VK_FORMAT_B8G8R8_SRGB
= 0x000000A0,
746 VK_FORMAT_B8G8R8A8_UNORM
= 0x000000A1,
747 VK_FORMAT_B8G8R8A8_SNORM
= 0x000000A2,
748 VK_FORMAT_B8G8R8A8_USCALED
= 0x000000A3,
749 VK_FORMAT_B8G8R8A8_SSCALED
= 0x000000A4,
750 VK_FORMAT_B8G8R8A8_UINT
= 0x000000A5,
751 VK_FORMAT_B8G8R8A8_SINT
= 0x000000A6,
752 VK_FORMAT_B8G8R8A8_SRGB
= 0x000000A7,
753 VK_FORMAT_B10G10R10A2_UNORM
= 0x000000A8,
754 VK_FORMAT_B10G10R10A2_SNORM
= 0x000000A9,
755 VK_FORMAT_B10G10R10A2_USCALED
= 0x000000AA,
756 VK_FORMAT_B10G10R10A2_SSCALED
= 0x000000AB,
757 VK_FORMAT_B10G10R10A2_UINT
= 0x000000AC,
758 VK_FORMAT_B10G10R10A2_SINT
= 0x000000AD,
760 VK_ENUM_RANGE(FORMAT
, UNDEFINED
, B10G10R10A2_SINT
)
763 // Shader stage enumerant
764 typedef enum VkShaderStage_
766 VK_SHADER_STAGE_VERTEX
= 0,
767 VK_SHADER_STAGE_TESS_CONTROL
= 1,
768 VK_SHADER_STAGE_TESS_EVALUATION
= 2,
769 VK_SHADER_STAGE_GEOMETRY
= 3,
770 VK_SHADER_STAGE_FRAGMENT
= 4,
771 VK_SHADER_STAGE_COMPUTE
= 5,
773 VK_ENUM_RANGE(SHADER_STAGE
, VERTEX
, COMPUTE
)
776 // Structure type enumerant
777 typedef enum VkStructureType_
779 VK_STRUCTURE_TYPE_APPLICATION_INFO
= 0,
780 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
= 1,
781 VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
= 2,
782 VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO
= 3,
783 VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO
= 4,
784 VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO
= 5,
785 VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
= 6,
786 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
= 7,
787 VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
= 8,
788 VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
= 9,
789 VK_STRUCTURE_TYPE_SHADER_CREATE_INFO
= 10,
790 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
= 11,
791 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
= 12,
792 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
= 13,
793 VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO
= 14,
794 VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
= 15,
795 VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO
= 16,
796 VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO
= 17,
797 VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
= 18,
798 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
= 19,
799 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
= 20,
800 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
= 21,
801 VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
= 22,
802 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
= 23,
803 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
= 24,
804 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
= 25,
805 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
= 26,
806 VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
= 27,
807 VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
= 28,
808 VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO
= 29,
809 VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
= 30,
810 VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO
= 31,
811 VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
= 32,
812 VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO
= 33,
813 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
= 34,
814 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
= 35,
815 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
= 36,
816 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
= 37,
817 VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
= 38,
818 VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO
= 39,
819 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
= 40,
820 VK_STRUCTURE_TYPE_LAYER_CREATE_INFO
= 41,
821 VK_STRUCTURE_TYPE_MEMORY_BARRIER
= 42,
822 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
= 43,
823 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
= 44,
824 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
= 45,
825 VK_STRUCTURE_TYPE_UPDATE_SAMPLERS
= 46,
826 VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES
= 47,
827 VK_STRUCTURE_TYPE_UPDATE_IMAGES
= 48,
828 VK_STRUCTURE_TYPE_UPDATE_BUFFERS
= 49,
829 VK_STRUCTURE_TYPE_UPDATE_AS_COPY
= 50,
830 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
= 51,
831 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
= 52,
833 VK_ENUM_RANGE(STRUCTURE_TYPE
, APPLICATION_INFO
, PIPELINE_LAYOUT_CREATE_INFO
)
836 // Object type enumerant
837 typedef enum VkObjectType_
839 VK_OBJECT_TYPE_INSTANCE
= 0,
840 VK_OBJECT_TYPE_PHYSICAL_DEVICE
= 1,
841 VK_OBJECT_TYPE_DEVICE
= 2,
842 VK_OBJECT_TYPE_QUEUE
= 3,
843 VK_OBJECT_TYPE_COMMAND_BUFFER
= 4,
844 VK_OBJECT_TYPE_DEVICE_MEMORY
= 5,
845 VK_OBJECT_TYPE_BUFFER
= 6,
846 VK_OBJECT_TYPE_BUFFER_VIEW
= 7,
847 VK_OBJECT_TYPE_IMAGE
= 8,
848 VK_OBJECT_TYPE_IMAGE_VIEW
= 9,
849 VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW
= 10,
850 VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW
= 11,
851 VK_OBJECT_TYPE_SHADER
= 12,
852 VK_OBJECT_TYPE_PIPELINE
= 13,
853 VK_OBJECT_TYPE_PIPELINE_LAYOUT
= 14,
854 VK_OBJECT_TYPE_SAMPLER
= 15,
855 VK_OBJECT_TYPE_DESCRIPTOR_SET
= 16,
856 VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT
= 17,
857 VK_OBJECT_TYPE_DESCRIPTOR_POOL
= 18,
858 VK_OBJECT_TYPE_DYNAMIC_VP_STATE
= 19,
859 VK_OBJECT_TYPE_DYNAMIC_RS_STATE
= 20,
860 VK_OBJECT_TYPE_DYNAMIC_CB_STATE
= 21,
861 VK_OBJECT_TYPE_DYNAMIC_DS_STATE
= 22,
862 VK_OBJECT_TYPE_FENCE
= 23,
863 VK_OBJECT_TYPE_SEMAPHORE
= 24,
864 VK_OBJECT_TYPE_EVENT
= 25,
865 VK_OBJECT_TYPE_QUERY_POOL
= 26,
866 VK_OBJECT_TYPE_FRAMEBUFFER
= 27,
867 VK_OBJECT_TYPE_RENDER_PASS
= 28,
869 // Valid ranges for core Vulkan:
870 VK_OBJECT_TYPE_BEGIN_RANGE
= VK_OBJECT_TYPE_INSTANCE
,
871 VK_OBJECT_TYPE_END_RANGE
= VK_OBJECT_TYPE_RENDER_PASS
,
872 VK_NUM_OBJECT_TYPE
= (VK_OBJECT_TYPE_END_RANGE
- VK_OBJECT_TYPE_BEGIN_RANGE
+ 1),
873 VK_MAX_ENUM(VkObjectType
)
876 // ------------------------------------------------------------------------------------------------
877 // Error and return codes
879 typedef enum VkResult_
881 // Return codes for successful operation execution (> = 0)
882 VK_SUCCESS
= 0x0000000,
883 VK_UNSUPPORTED
= 0x0000001,
884 VK_NOT_READY
= 0x0000002,
885 VK_TIMEOUT
= 0x0000003,
886 VK_EVENT_SET
= 0x0000004,
887 VK_EVENT_RESET
= 0x0000005,
889 // Error codes (negative values)
890 VK_ERROR_UNKNOWN
= -(0x00000001),
891 VK_ERROR_UNAVAILABLE
= -(0x00000002),
892 VK_ERROR_INITIALIZATION_FAILED
= -(0x00000003),
893 VK_ERROR_OUT_OF_HOST_MEMORY
= -(0x00000004),
894 VK_ERROR_OUT_OF_DEVICE_MEMORY
= -(0x00000005),
895 VK_ERROR_DEVICE_ALREADY_CREATED
= -(0x00000006),
896 VK_ERROR_DEVICE_LOST
= -(0x00000007),
897 VK_ERROR_INVALID_POINTER
= -(0x00000008),
898 VK_ERROR_INVALID_VALUE
= -(0x00000009),
899 VK_ERROR_INVALID_HANDLE
= -(0x0000000A),
900 VK_ERROR_INVALID_ORDINAL
= -(0x0000000B),
901 VK_ERROR_INVALID_MEMORY_SIZE
= -(0x0000000C),
902 VK_ERROR_INVALID_EXTENSION
= -(0x0000000D),
903 VK_ERROR_INVALID_FLAGS
= -(0x0000000E),
904 VK_ERROR_INVALID_ALIGNMENT
= -(0x0000000F),
905 VK_ERROR_INVALID_FORMAT
= -(0x00000010),
906 VK_ERROR_INVALID_IMAGE
= -(0x00000011),
907 VK_ERROR_INVALID_DESCRIPTOR_SET_DATA
= -(0x00000012),
908 VK_ERROR_INVALID_QUEUE_TYPE
= -(0x00000013),
909 VK_ERROR_INVALID_OBJECT_TYPE
= -(0x00000014),
910 VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION
= -(0x00000015),
911 VK_ERROR_BAD_SHADER_CODE
= -(0x00000016),
912 VK_ERROR_BAD_PIPELINE_DATA
= -(0x00000017),
913 VK_ERROR_TOO_MANY_MEMORY_REFERENCES
= -(0x00000018),
914 VK_ERROR_NOT_MAPPABLE
= -(0x00000019),
915 VK_ERROR_MEMORY_MAP_FAILED
= -(0x0000001A),
916 VK_ERROR_MEMORY_UNMAP_FAILED
= -(0x0000001B),
917 VK_ERROR_INCOMPATIBLE_DEVICE
= -(0x0000001C),
918 VK_ERROR_INCOMPATIBLE_DRIVER
= -(0x0000001D),
919 VK_ERROR_INCOMPLETE_COMMAND_BUFFER
= -(0x0000001E),
920 VK_ERROR_BUILDING_COMMAND_BUFFER
= -(0x0000001F),
921 VK_ERROR_MEMORY_NOT_BOUND
= -(0x00000020),
922 VK_ERROR_INCOMPATIBLE_QUEUE
= -(0x00000021),
923 VK_ERROR_NOT_SHAREABLE
= -(0x00000022),
928 // ------------------------------------------------------------------------------------------------
931 // Device creation flags
932 typedef VkFlags VkDeviceCreateFlags
;
933 typedef enum VkDeviceCreateFlagBits_
935 VK_DEVICE_CREATE_VALIDATION_BIT
= VK_BIT(0),
936 VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT
= VK_BIT(1),
937 } VkDeviceCreateFlagBits
;
939 // Queue capabilities
940 typedef VkFlags VkQueueFlags
;
941 typedef enum VkQueueFlagBits_
943 VK_QUEUE_GRAPHICS_BIT
= VK_BIT(0), // Queue supports graphics operations
944 VK_QUEUE_COMPUTE_BIT
= VK_BIT(1), // Queue supports compute operations
945 VK_QUEUE_DMA_BIT
= VK_BIT(2), // Queue supports DMA operations
946 VK_QUEUE_MEMMGR_BIT
= VK_BIT(3), // Queue supports memory management operations
947 VK_QUEUE_EXTENDED_BIT
= VK_BIT(30), // Extended queue
950 // Memory properties passed into vkAllocMemory().
951 typedef VkFlags VkMemoryPropertyFlags
;
952 typedef enum VkMemoryPropertyFlagBits_
954 VK_MEMORY_PROPERTY_DEVICE_ONLY
= 0, // If otherwise stated, then allocate memory on device
955 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
= VK_BIT(0), // Memory should be mappable by host
956 VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT
= VK_BIT(1), // Memory should be coherent between host and device accesses
957 VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT
= VK_BIT(2), // Memory should not be cached by the host
958 VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT
= VK_BIT(3), // Memory should support host write combining
959 VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL
= VK_BIT(4), // If set, prefer host access
960 VK_MEMORY_PROPERTY_SHAREABLE_BIT
= VK_BIT(5),
961 } VkMemoryPropertyFlagBits
;
963 // Memory output flags passed to resource transition commands
964 typedef VkFlags VkMemoryOutputFlags
;
965 typedef enum VkMemoryOutputFlagBits_
967 VK_MEMORY_OUTPUT_CPU_WRITE_BIT
= VK_BIT(0), // Controls output coherency of CPU writes
968 VK_MEMORY_OUTPUT_SHADER_WRITE_BIT
= VK_BIT(1), // Controls output coherency of generic shader writes
969 VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT
= VK_BIT(2), // Controls output coherency of color attachment writes
970 VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT
= VK_BIT(3), // Controls output coherency of depth/stencil attachment writes
971 VK_MEMORY_OUTPUT_TRANSFER_BIT
= VK_BIT(4), // Controls output coherency of transfer operations
972 } VkMemoryOutputFlagBits
;
974 // Memory input flags passed to resource transition commands
975 typedef VkFlags VkMemoryInputFlags
;
976 typedef enum VkMemoryInputFlagBits_
978 VK_MEMORY_INPUT_CPU_READ_BIT
= VK_BIT(0), // Controls input coherency of CPU reads
979 VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT
= VK_BIT(1), // Controls input coherency of indirect command reads
980 VK_MEMORY_INPUT_INDEX_FETCH_BIT
= VK_BIT(2), // Controls input coherency of index fetches
981 VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT
= VK_BIT(3), // Controls input coherency of vertex attribute fetches
982 VK_MEMORY_INPUT_UNIFORM_READ_BIT
= VK_BIT(4), // Controls input coherency of uniform buffer reads
983 VK_MEMORY_INPUT_SHADER_READ_BIT
= VK_BIT(5), // Controls input coherency of generic shader reads
984 VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT
= VK_BIT(6), // Controls input coherency of color attachment reads
985 VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT
= VK_BIT(7), // Controls input coherency of depth/stencil attachment reads
986 VK_MEMORY_INPUT_TRANSFER_BIT
= VK_BIT(8), // Controls input coherency of transfer operations
987 } VkMemoryInputFlagBits
;
989 // Buffer usage flags
990 typedef VkFlags VkBufferUsageFlags
;
991 typedef enum VkBufferUsageFlagBits_
993 VK_BUFFER_USAGE_GENERAL
= 0, // No special usage
994 VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT
= VK_BIT(0), // Can be used as a source of transfer operations
995 VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT
= VK_BIT(1), // Can be used as a destination of transfer operations
996 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
= VK_BIT(2), // Can be used as TBO
997 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
= VK_BIT(3), // Can be used as IBO
998 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
= VK_BIT(4), // Can be used as UBO
999 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
= VK_BIT(5), // Can be used as SSBO
1000 VK_BUFFER_USAGE_INDEX_BUFFER_BIT
= VK_BIT(6), // Can be used as source of fixed function index fetch (index buffer)
1001 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
= VK_BIT(7), // Can be used as source of fixed function vertex fetch (VBO)
1002 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
= VK_BIT(8), // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
1003 } VkBufferUsageFlagBits
;
1005 // Buffer creation flags
1006 typedef VkFlags VkBufferCreateFlags
;
1007 typedef enum VkBufferCreateFlagBits_
1009 VK_BUFFER_CREATE_SHAREABLE_BIT
= VK_BIT(0), // Buffer should be shareable
1010 VK_BUFFER_CREATE_SPARSE_BIT
= VK_BIT(1), // Buffer should support sparse backing
1011 } VkBufferCreateFlagBits
;
1013 // Shader stage flags
1014 typedef VkFlags VkShaderStageFlags
;
1015 typedef enum VkShaderStageFlagBits_
1017 VK_SHADER_STAGE_VERTEX_BIT
= VK_BIT(0),
1018 VK_SHADER_STAGE_TESS_CONTROL_BIT
= VK_BIT(1),
1019 VK_SHADER_STAGE_TESS_EVALUATION_BIT
= VK_BIT(2),
1020 VK_SHADER_STAGE_GEOMETRY_BIT
= VK_BIT(3),
1021 VK_SHADER_STAGE_FRAGMENT_BIT
= VK_BIT(4),
1022 VK_SHADER_STAGE_COMPUTE_BIT
= VK_BIT(5),
1024 VK_SHADER_STAGE_ALL
= 0x7FFFFFFF,
1025 } VkShaderStageFlagBits
;
1027 // Image usage flags
1028 typedef VkFlags VkImageUsageFlags
;
1029 typedef enum VkImageUsageFlagBits_
1031 VK_IMAGE_USAGE_GENERAL
= 0, // No special usage
1032 VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT
= VK_BIT(0), // Can be used as a source of transfer operations
1033 VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT
= VK_BIT(1), // Can be used as a destination of transfer operations
1034 VK_IMAGE_USAGE_SAMPLED_BIT
= VK_BIT(2), // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
1035 VK_IMAGE_USAGE_STORAGE_BIT
= VK_BIT(3), // Can be used as storage image (STORAGE_IMAGE descriptor type)
1036 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
= VK_BIT(4), // Can be used as framebuffer color attachment
1037 VK_IMAGE_USAGE_DEPTH_STENCIL_BIT
= VK_BIT(5), // Can be used as framebuffer depth/stencil attachment
1038 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
= VK_BIT(6), // Image data not needed outside of rendering
1039 } VkImageUsageFlagBits
;
1041 // Image creation flags
1042 typedef VkFlags VkImageCreateFlags
;
1043 typedef enum VkImageCreateFlagBits_
1045 VK_IMAGE_CREATE_INVARIANT_DATA_BIT
= VK_BIT(0),
1046 VK_IMAGE_CREATE_CLONEABLE_BIT
= VK_BIT(1),
1047 VK_IMAGE_CREATE_SHAREABLE_BIT
= VK_BIT(2), // Image should be shareable
1048 VK_IMAGE_CREATE_SPARSE_BIT
= VK_BIT(3), // Image should support sparse backing
1049 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
= VK_BIT(4), // Allows image views to have different format than the base image
1050 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
= VK_BIT(5), // Allows creating image views with cube type from the created image
1051 } VkImageCreateFlagBits
;
1053 // Depth-stencil view creation flags
1054 typedef VkFlags VkDepthStencilViewCreateFlags
;
1055 typedef enum VkDepthStencilViewCreateFlagBits_
1057 VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT
= VK_BIT(0),
1058 VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT
= VK_BIT(1),
1059 } VkDepthStencilViewCreateFlagBits
;
1061 // Pipeline creation flags
1062 typedef VkFlags VkPipelineCreateFlags
;
1063 typedef enum VkPipelineCreateFlagBits_
1065 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT
= VK_BIT(0),
1066 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT
= VK_BIT(1),
1067 } VkPipelineCreateFlagBits
;
1070 typedef VkFlags VkChannelFlags
;
1071 typedef enum VkChannelFlagBits_
1073 VK_CHANNEL_R_BIT
= VK_BIT(0),
1074 VK_CHANNEL_G_BIT
= VK_BIT(1),
1075 VK_CHANNEL_B_BIT
= VK_BIT(2),
1076 VK_CHANNEL_A_BIT
= VK_BIT(3),
1077 } VkChannelFlagBits
;
1079 // Fence creation flags
1080 typedef VkFlags VkFenceCreateFlags
;
1081 typedef enum VkFenceCreateFlagBits_
1083 VK_FENCE_CREATE_SIGNALED_BIT
= VK_BIT(0),
1084 } VkFenceCreateFlagBits
;
1086 // Semaphore creation flags
1087 typedef VkFlags VkSemaphoreCreateFlags
;
1088 typedef enum VkSemaphoreCreateFlagBits_
1090 VK_SEMAPHORE_CREATE_SHAREABLE_BIT
= VK_BIT(0),
1091 } VkSemaphoreCreateFlagBits
;
1093 // Format capability flags
1094 typedef VkFlags VkFormatFeatureFlags
;
1095 typedef enum VkFormatFeatureFlagBits_
1097 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
= VK_BIT(0), // Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
1098 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
= VK_BIT(1), // Format can be used for storage images (STORAGE_IMAGE descriptor type)
1099 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
= VK_BIT(2), // Format supports atomic operations in case it's used for storage images
1100 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
= VK_BIT(3), // Format can be used for uniform texel buffers (TBOs)
1101 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
= VK_BIT(4), // Format can be used for storage texel buffers (IBOs)
1102 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
= VK_BIT(5), // Format supports atomic operations in case it's used for storage texel buffers
1103 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
= VK_BIT(6), // Format can be used for vertex buffers (VBOs)
1104 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
= VK_BIT(7), // Format can be used for color attachment images
1105 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
= VK_BIT(8), // Format supports blending in case it's used for color attachment images
1106 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
= VK_BIT(9), // Format can be used for depth/stencil attachment images
1107 VK_FORMAT_FEATURE_CONVERSION_BIT
= VK_BIT(10), // Format can be used as the source or destination of format converting blits
1108 } VkFormatFeatureFlagBits
;
1110 // Query control flags
1111 typedef VkFlags VkQueryControlFlags
;
1112 typedef enum VkQueryControlFlagBits_
1114 VK_QUERY_CONTROL_CONSERVATIVE_BIT
= VK_BIT(0), // Allow conservative results to be collected by the query
1115 } VkQueryControlFlagBits
;
1117 // Query result flags
1118 typedef VkFlags VkQueryResultFlags
;
1119 typedef enum VkQueryResultFlagBits_
1121 VK_QUERY_RESULT_32_BIT
= 0, // Results of the queries are written to the destination buffer as 32-bit values
1122 VK_QUERY_RESULT_64_BIT
= VK_BIT(0), // Results of the queries are written to the destination buffer as 64-bit values
1123 VK_QUERY_RESULT_NO_WAIT_BIT
= 0, // Results of the queries aren't waited on before proceeding with the result copy
1124 VK_QUERY_RESULT_WAIT_BIT
= VK_BIT(1), // Results of the queries are waited on before proceeding with the result copy
1125 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT
= VK_BIT(2), // Besides the results of the query, the availability of the results is also written
1126 VK_QUERY_RESULT_PARTIAL_BIT
= VK_BIT(3), // Copy the partial results of the query even if the final results aren't available
1127 } VkQueryResultFlagBits
;
1129 // Physical device compatibility flags
1130 typedef VkFlags VkPhysicalDeviceCompatibilityFlags
;
1131 typedef enum VkPhysicalDeviceCompatibilityFlagBits_
1133 VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT
= VK_BIT(0),
1134 VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT
= VK_BIT(1),
1135 VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT
= VK_BIT(2),
1136 VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT
= VK_BIT(3),
1137 VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT
= VK_BIT(4),
1138 VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT
= VK_BIT(5),
1139 VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT
= VK_BIT(6),
1140 } VkPhysicalDeviceCompatibilityFlagBits
;
1142 // Shader creation flags
1143 typedef VkFlags VkShaderCreateFlags
;
1145 // Event creation flags
1146 typedef VkFlags VkEventCreateFlags
;
1148 // Command buffer creation flags
1149 typedef VkFlags VkCmdBufferCreateFlags
;
1151 // Command buffer optimization flags
1152 typedef VkFlags VkCmdBufferOptimizeFlags
;
1153 typedef enum VkCmdBufferOptimizeFlagBits_
1155 VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT
= VK_BIT(0),
1156 VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT
= VK_BIT(1),
1157 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT
= VK_BIT(2),
1158 VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT
= VK_BIT(3),
1159 } VkCmdBufferOptimizeFlagBits
;
1161 // Pipeline statistics flags
1162 typedef VkFlags VkQueryPipelineStatisticFlags
;
1163 typedef enum VkQueryPipelineStatisticFlagBits_
{
1164 VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT
= VK_BIT(0), // Optional
1165 VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT
= VK_BIT(1), // Optional
1166 VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT
= VK_BIT(2), // Optional
1167 VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT
= VK_BIT(3), // Optional
1168 VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT
= VK_BIT(4), // Optional
1169 VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT
= VK_BIT(5), // Optional
1170 VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT
= VK_BIT(6), // Optional
1171 VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT
= VK_BIT(7), // Optional
1172 VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT
= VK_BIT(8), // Optional
1173 VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT
= VK_BIT(9), // Optional
1174 VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT
= VK_BIT(10), // Optional
1175 } VkQueryPipelineStatisticFlagBits
;
1177 // Memory mapping flags
1178 typedef VkFlags VkMemoryMapFlags
;
1180 // ------------------------------------------------------------------------------------------------
1181 // Vulkan structures
1184 VkStructureType sType
;
1186 const char* pAppName
;
1187 uint32_t appVersion
;
1188 const char* pEngineName
;
1189 uint32_t engineVersion
;
1190 uint32_t apiVersion
;
1191 } VkApplicationInfo
;
1193 typedef void* (VKAPI
*PFN_vkAllocFunction
)(
1197 VkSystemAllocType allocType
);
1199 typedef void (VKAPI
*PFN_vkFreeFunction
)(
1205 PFN_vkAllocFunction pfnAlloc
;
1206 PFN_vkFreeFunction pfnFree
;
1210 VkStructureType sType
;
1212 const VkApplicationInfo
* pAppInfo
;
1213 const VkAllocCallbacks
* pAllocCb
;
1214 uint32_t extensionCount
;
1215 const char*const* ppEnabledExtensionNames
;
1216 } VkInstanceCreateInfo
;
1219 uint32_t apiVersion
;
1220 uint32_t driverVersion
;
1223 VkPhysicalDeviceType deviceType
;
1224 char deviceName
[VK_MAX_PHYSICAL_DEVICE_NAME
];
1225 VkDeviceSize maxInlineMemoryUpdateSize
;
1226 uint32_t maxBoundDescriptorSets
;
1227 uint32_t maxThreadGroupSize
;
1228 uint64_t timestampFrequency
;
1229 bool32_t multiColorAttachmentClears
;
1230 uint32_t maxDescriptorSets
;
1231 uint32_t maxViewports
;
1232 uint32_t maxColorAttachments
;
1233 } VkPhysicalDeviceProperties
;
1236 float maxDeviceClock
;
1239 float primsPerClock
;
1240 float pixelsPerClock
;
1241 } VkPhysicalDevicePerformance
;
1244 VkPhysicalDeviceCompatibilityFlags compatibilityFlags
;
1245 } VkPhysicalDeviceCompatibilityInfo
;
1248 VkQueueFlags queueFlags
;
1249 uint32_t queueCount
;
1250 bool32_t supportsTimestamps
;
1251 } VkPhysicalDeviceQueueProperties
;
1254 bool32_t supportsMigration
;
1255 bool32_t supportsPinning
;
1256 } VkPhysicalDeviceMemoryProperties
;
1259 uint32_t queueNodeIndex
;
1260 uint32_t queueCount
;
1261 } VkDeviceQueueCreateInfo
;
1264 VkStructureType sType
;
1266 uint32_t queueRecordCount
;
1267 const VkDeviceQueueCreateInfo
* pRequestedQueues
;
1268 uint32_t extensionCount
;
1269 const char*const* ppEnabledExtensionNames
;
1270 VkDeviceCreateFlags flags
;
1271 } VkDeviceCreateInfo
;
1274 char extName
[VK_MAX_EXTENSION_NAME
];
1276 } VkExtensionProperties
;
1279 VkStructureType sType
;
1281 VkDeviceSize allocationSize
;
1282 VkMemoryPropertyFlags memProps
;
1283 } VkMemoryAllocInfo
;
1286 VkStructureType sType
;
1288 VkDeviceMemory sharedMem
;
1293 VkDeviceSize alignment
;
1294 VkDeviceSize granularity
;
1295 VkMemoryPropertyFlags memPropsAllowed
;
1296 VkMemoryPropertyFlags memPropsRequired
;
1297 } VkMemoryRequirements
;
1300 VkImageAspect aspect
;
1302 uint32_t arraySlice
;
1303 } VkImageSubresource
;
1318 VkImageSubresource subresource
;
1321 } VkImageMemoryBindInfo
;
1324 VkStructureType sType
;
1326 VkFenceCreateFlags flags
;
1327 } VkFenceCreateInfo
;
1330 VkStructureType sType
;
1332 uint32_t initialCount
;
1333 VkSemaphoreCreateFlags flags
;
1334 } VkSemaphoreCreateInfo
;
1337 VkStructureType sType
;
1339 VkSemaphore sharedSemaphore
;
1340 } VkSemaphoreOpenInfo
;
1343 VkStructureType sType
;
1345 VkEventCreateFlags flags
;
1346 } VkEventCreateInfo
;
1349 VkStructureType sType
;
1351 VkQueryType queryType
;
1353 VkQueryPipelineStatisticFlags pipelineStatistics
;
1354 } VkQueryPoolCreateInfo
;
1357 VkStructureType sType
;
1360 VkBufferUsageFlags usage
;
1361 VkBufferCreateFlags flags
;
1362 } VkBufferCreateInfo
;
1365 VkStructureType sType
;
1368 VkBufferViewType viewType
;
1370 VkDeviceSize offset
;
1372 } VkBufferViewCreateInfo
;
1375 VkStructureType sType
;
1377 VkImageType imageType
;
1383 VkImageTiling tiling
;
1384 VkImageUsageFlags usage
;
1385 VkImageCreateFlags flags
;
1386 } VkImageCreateInfo
;
1389 VkImage originalImage
;
1390 } VkPeerImageOpenInfo
;
1393 VkDeviceSize offset
;
1395 VkDeviceSize rowPitch
;
1396 VkDeviceSize depthPitch
;
1397 } VkSubresourceLayout
;
1407 VkImageAspect aspect
;
1408 uint32_t baseMipLevel
;
1410 uint32_t baseArraySlice
;
1412 } VkImageSubresourceRange
;
1415 VkStructureType sType
;
1418 VkImageViewType viewType
;
1420 VkChannelMapping channels
;
1421 VkImageSubresourceRange subresourceRange
;
1423 } VkImageViewCreateInfo
;
1426 VkStructureType sType
;
1431 uint32_t baseArraySlice
;
1433 VkImage msaaResolveImage
;
1434 VkImageSubresourceRange msaaResolveSubResource
;
1435 } VkColorAttachmentViewCreateInfo
;
1438 VkStructureType sType
;
1442 uint32_t baseArraySlice
;
1444 VkImage msaaResolveImage
;
1445 VkImageSubresourceRange msaaResolveSubResource
;
1446 VkDepthStencilViewCreateFlags flags
;
1447 } VkDepthStencilViewCreateInfo
;
1450 VkStructureType sType
;
1454 VkShaderCreateFlags flags
;
1455 } VkShaderCreateInfo
;
1458 uint32_t constantId
;
1460 } VkSpecializationMapEntry
;
1465 const void* pBufferData
;
1466 } VkLinkConstBuffer
;
1469 uint32_t mapEntryCount
;
1470 const VkSpecializationMapEntry
* pMap
;
1472 } VkSpecializationInfo
;
1475 VkShaderStage stage
;
1477 uint32_t linkConstBufferCount
;
1478 const VkLinkConstBuffer
* pLinkConstBufferInfo
;
1479 const VkSpecializationInfo
* pSpecializationInfo
;
1483 VkStructureType sType
;
1485 VkPipelineShader shader
;
1486 } VkPipelineShaderStageCreateInfo
;
1490 uint32_t strideInBytes
;
1491 VkVertexInputStepRate stepRate
;
1492 } VkVertexInputBindingDescription
;
1498 uint32_t offsetInBytes
;
1499 } VkVertexInputAttributeDescription
;
1502 VkStructureType sType
;
1504 uint32_t bindingCount
;
1505 const VkVertexInputBindingDescription
* pVertexBindingDescriptions
;
1506 uint32_t attributeCount
;
1507 const VkVertexInputAttributeDescription
* pVertexAttributeDescriptions
;
1508 } VkPipelineVertexInputCreateInfo
;
1511 VkStructureType sType
;
1513 VkPrimitiveTopology topology
;
1514 bool32_t disableVertexReuse
;
1515 bool32_t primitiveRestartEnable
;
1516 uint32_t primitiveRestartIndex
;
1517 } VkPipelineIaStateCreateInfo
;
1520 VkStructureType sType
;
1522 uint32_t patchControlPoints
;
1523 } VkPipelineTessStateCreateInfo
;
1526 VkStructureType sType
;
1528 uint32_t viewportCount
;
1529 VkCoordinateOrigin clipOrigin
;
1530 VkDepthMode depthMode
;
1531 } VkPipelineVpStateCreateInfo
;
1534 VkStructureType sType
;
1536 bool32_t depthClipEnable
;
1537 bool32_t rasterizerDiscardEnable
;
1538 bool32_t programPointSize
;
1539 VkCoordinateOrigin pointOrigin
;
1540 VkProvokingVertex provokingVertex
;
1541 VkFillMode fillMode
;
1542 VkCullMode cullMode
;
1543 VkFrontFace frontFace
;
1544 } VkPipelineRsStateCreateInfo
;
1547 VkStructureType sType
;
1550 bool32_t multisampleEnable
;
1551 bool32_t sampleShadingEnable
;
1552 float minSampleShading
;
1553 VkSampleMask sampleMask
;
1554 } VkPipelineMsStateCreateInfo
;
1557 VkStencilOp stencilFailOp
;
1558 VkStencilOp stencilPassOp
;
1559 VkStencilOp stencilDepthFailOp
;
1560 VkCompareOp stencilCompareOp
;
1564 VkStructureType sType
;
1567 bool32_t depthTestEnable
;
1568 bool32_t depthWriteEnable
;
1569 VkCompareOp depthCompareOp
;
1570 bool32_t depthBoundsEnable
;
1571 bool32_t stencilTestEnable
;
1572 VkStencilOpState front
;
1573 VkStencilOpState back
;
1574 } VkPipelineDsStateCreateInfo
;
1577 bool32_t blendEnable
;
1579 VkBlend srcBlendColor
;
1580 VkBlend destBlendColor
;
1581 VkBlendOp blendOpColor
;
1582 VkBlend srcBlendAlpha
;
1583 VkBlend destBlendAlpha
;
1584 VkBlendOp blendOpAlpha
;
1585 VkChannelFlags channelWriteMask
;
1586 } VkPipelineCbAttachmentState
;
1589 VkStructureType sType
;
1591 bool32_t alphaToCoverageEnable
;
1592 bool32_t logicOpEnable
;
1594 uint32_t attachmentCount
;
1595 const VkPipelineCbAttachmentState
* pAttachments
;
1596 } VkPipelineCbStateCreateInfo
;
1599 VkStructureType sType
;
1601 VkPipelineCreateFlags flags
;
1602 VkPipelineLayout layout
;
1603 } VkGraphicsPipelineCreateInfo
;
1606 VkStructureType sType
;
1608 VkPipelineShader cs
;
1609 VkPipelineCreateFlags flags
;
1610 VkPipelineLayout layout
;
1611 } VkComputePipelineCreateInfo
;
1614 VkStructureType sType
;
1616 uint32_t descriptorSetCount
;
1617 const VkDescriptorSetLayout
* pSetLayouts
;
1618 } VkPipelineLayoutCreateInfo
;
1621 VkStructureType sType
;
1623 VkTexFilter magFilter
;
1624 VkTexFilter minFilter
;
1625 VkTexMipmapMode mipMode
;
1626 VkTexAddress addressU
;
1627 VkTexAddress addressV
;
1628 VkTexAddress addressW
;
1630 uint32_t maxAnisotropy
;
1631 VkCompareOp compareOp
;
1634 VkBorderColor borderColor
;
1635 } VkSamplerCreateInfo
;
1638 VkDescriptorType descriptorType
;
1640 VkShaderStageFlags stageFlags
;
1641 const VkSampler
* pImmutableSamplers
;
1642 } VkDescriptorSetLayoutBinding
;
1645 VkStructureType sType
;
1648 const VkDescriptorSetLayoutBinding
* pBinding
;
1649 } VkDescriptorSetLayoutCreateInfo
;
1652 VkDescriptorType type
;
1654 } VkDescriptorTypeCount
;
1657 VkStructureType sType
;
1660 const VkDescriptorTypeCount
* pTypeCount
;
1661 } VkDescriptorPoolCreateInfo
;
1688 VkStructureType sType
;
1690 uint32_t viewportAndScissorCount
;
1691 const VkViewport
* pViewports
;
1692 const VkRect
* pScissors
;
1693 } VkDynamicVpStateCreateInfo
;
1696 VkStructureType sType
;
1699 float depthBiasClamp
;
1700 float slopeScaledDepthBias
;
1702 float pointFadeThreshold
;
1704 } VkDynamicRsStateCreateInfo
;
1707 VkStructureType sType
;
1709 float blendConst
[4];
1710 } VkDynamicCbStateCreateInfo
;
1713 VkStructureType sType
;
1717 uint32_t stencilReadMask
;
1718 uint32_t stencilWriteMask
;
1719 uint32_t stencilFrontRef
;
1720 uint32_t stencilBackRef
;
1721 } VkDynamicDsStateCreateInfo
;
1724 VkColorAttachmentView view
;
1725 VkImageLayout layout
;
1726 } VkColorAttachmentBindInfo
;
1729 VkDepthStencilView view
;
1730 VkImageLayout layout
;
1731 } VkDepthStencilBindInfo
;
1734 VkStructureType sType
;
1736 uint32_t colorAttachmentCount
;
1737 const VkColorAttachmentBindInfo
* pColorAttachments
;
1738 const VkDepthStencilBindInfo
* pDepthStencilAttachment
;
1739 uint32_t sampleCount
;
1743 } VkFramebufferCreateInfo
;
1745 // Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared.
1746 typedef union VkClearColorValue_
1748 float floatColor
[4];
1749 uint32_t rawColor
[4];
1750 } VkClearColorValue
;
1753 VkClearColorValue color
;
1754 bool32_t useRawValue
;
1758 VkStructureType sType
;
1762 uint32_t colorAttachmentCount
;
1764 uint32_t sampleCount
;
1766 const VkFormat
* pColorFormats
;
1767 const VkImageLayout
* pColorLayouts
;
1768 const VkAttachmentLoadOp
* pColorLoadOps
;
1769 const VkAttachmentStoreOp
* pColorStoreOps
;
1770 const VkClearColor
* pColorLoadClearValues
;
1771 VkFormat depthStencilFormat
;
1772 VkImageLayout depthStencilLayout
;
1773 VkAttachmentLoadOp depthLoadOp
;
1774 float depthLoadClearValue
;
1775 VkAttachmentStoreOp depthStoreOp
;
1776 VkAttachmentLoadOp stencilLoadOp
;
1777 uint32_t stencilLoadClearValue
;
1778 VkAttachmentStoreOp stencilStoreOp
;
1779 } VkRenderPassCreateInfo
;
1782 VkStructureType sType
;
1784 uint32_t queueNodeIndex
;
1785 VkCmdBufferCreateFlags flags
;
1786 } VkCmdBufferCreateInfo
;
1789 VkStructureType sType
;
1791 VkCmdBufferOptimizeFlags flags
;
1792 } VkCmdBufferBeginInfo
;
1795 VkDeviceSize srcOffset
;
1796 VkDeviceSize destOffset
;
1797 VkDeviceSize copySize
;
1801 VkImageSubresource srcSubresource
;
1802 VkOffset3D srcOffset
;
1803 VkImageSubresource destSubresource
;
1804 VkOffset3D destOffset
;
1809 VkImageSubresource srcSubresource
;
1810 VkOffset3D srcOffset
;
1811 VkExtent3D srcExtent
;
1812 VkImageSubresource destSubresource
;
1813 VkOffset3D destOffset
;
1814 VkExtent3D destExtent
;
1818 VkDeviceSize bufferOffset
;
1819 VkImageSubresource imageSubresource
;
1820 VkOffset3D imageOffset
;
1821 VkExtent3D imageExtent
;
1822 } VkBufferImageCopy
;
1825 VkImageSubresource srcSubresource
;
1826 VkOffset3D srcOffset
;
1827 VkImageSubresource destSubresource
;
1828 VkOffset3D destOffset
;
1833 VkRenderPass renderPass
;
1834 VkFramebuffer framebuffer
;
1835 } VkRenderPassBegin
;
1838 VkStructureType sType
;
1840 VkMemoryOutputFlags outputMask
;
1841 VkMemoryInputFlags inputMask
;
1843 VkDeviceSize offset
;
1845 } VkBufferMemoryBarrier
;
1851 } VkDispatchIndirectCmd
;
1854 uint32_t indexCount
;
1855 uint32_t instanceCount
;
1856 uint32_t firstIndex
;
1857 int32_t vertexOffset
;
1858 uint32_t firstInstance
;
1859 } VkDrawIndexedIndirectCmd
;
1862 uint32_t vertexCount
;
1863 uint32_t instanceCount
;
1864 uint32_t firstVertex
;
1865 uint32_t firstInstance
;
1866 } VkDrawIndirectCmd
;
1869 VkStructureType sType
;
1871 VkMemoryOutputFlags outputMask
;
1872 VkMemoryInputFlags inputMask
;
1873 VkImageLayout oldLayout
;
1874 VkImageLayout newLayout
;
1876 VkImageSubresourceRange subresourceRange
;
1877 } VkImageMemoryBarrier
;
1879 // can be added to VkDeviceCreateInfo via pNext
1881 VkStructureType sType
;
1883 uint32_t layerCount
;
1884 const char *const* ppActiveLayerNames
;
1885 } VkLayerCreateInfo
;
1888 VkStructureType sType
;
1890 VkMemoryOutputFlags outputMask
;
1891 VkMemoryInputFlags inputMask
;
1895 VkStructureType sType
;
1897 VkDeviceMemory originalMem
;
1898 } VkPeerMemoryOpenInfo
;
1901 VkFormatFeatureFlags linearTilingFeatures
;
1902 VkFormatFeatureFlags optimalTilingFeatures
;
1903 } VkFormatProperties
;
1906 VkStructureType sType
;
1909 } VkBufferViewAttachInfo
;
1912 VkStructureType sType
;
1915 VkImageLayout layout
;
1916 } VkImageViewAttachInfo
;
1919 VkStructureType sType
;
1922 uint32_t arrayIndex
;
1924 const VkSampler
* pSamplers
;
1929 const VkImageViewAttachInfo
* pImageView
;
1930 } VkSamplerImageViewInfo
;
1933 VkStructureType sType
;
1936 uint32_t arrayIndex
;
1938 const VkSamplerImageViewInfo
* pSamplerImageViews
;
1939 } VkUpdateSamplerTextures
;
1942 VkStructureType sType
;
1944 VkDescriptorType descriptorType
;
1946 uint32_t arrayIndex
;
1948 const VkImageViewAttachInfo
* pImageViews
;
1952 VkStructureType sType
;
1954 VkDescriptorType descriptorType
;
1956 uint32_t arrayIndex
;
1958 const VkBufferViewAttachInfo
* pBufferViews
;
1962 VkStructureType sType
;
1964 VkDescriptorType descriptorType
;
1965 VkDescriptorSet descriptorSet
;
1967 uint32_t arrayElement
;
1972 VkStructureType sType
;
1975 VkRenderPassBegin renderPassContinue
;
1976 } VkCmdBufferGraphicsBeginInfo
;
1978 // ------------------------------------------------------------------------------------------------
1980 typedef VkResult (VKAPI
*PFN_vkCreateInstance
)(const VkInstanceCreateInfo
* pCreateInfo
, VkInstance
* pInstance
);
1981 typedef VkResult (VKAPI
*PFN_vkDestroyInstance
)(VkInstance instance
);
1982 typedef VkResult (VKAPI
*PFN_vkEnumeratePhysicalDevices
)(VkInstance instance
, uint32_t* pPhysicalDeviceCount
, VkPhysicalDevice
* pPhysicalDevices
);
1983 typedef VkResult (VKAPI
*PFN_vkGetPhysicalDeviceInfo
)(VkPhysicalDevice physicalDevice
, VkPhysicalDeviceInfoType infoType
, size_t* pDataSize
, void* pData
);
1984 typedef void * (VKAPI
*PFN_vkGetProcAddr
)(VkPhysicalDevice physicalDevice
, const char * pName
);
1985 typedef VkResult (VKAPI
*PFN_vkCreateDevice
)(VkPhysicalDevice physicalDevice
, const VkDeviceCreateInfo
* pCreateInfo
, VkDevice
* pDevice
);
1986 typedef VkResult (VKAPI
*PFN_vkDestroyDevice
)(VkDevice device
);
1987 typedef VkResult (VKAPI
*PFN_vkGetGlobalExtensionInfo
)(VkExtensionInfoType infoType
, uint32_t extensionIndex
, size_t* pDataSize
, void* pData
);
1988 typedef VkResult (VKAPI
*PFN_vkGetPhysicalDeviceExtensionInfo
)(VkPhysicalDevice physicalDevice
, VkExtensionInfoType infoType
, uint32_t extensionIndex
, size_t* pDataSize
, void* pData
);
1989 typedef VkResult (VKAPI
*PFN_vkEnumerateLayers
)(VkPhysicalDevice physicalDevice
, size_t maxStringSize
, size_t* pLayerCount
, char* const* pOutLayers
, void* pReserved
);
1990 typedef VkResult (VKAPI
*PFN_vkGetDeviceQueue
)(VkDevice device
, uint32_t queueNodeIndex
, uint32_t queueIndex
, VkQueue
* pQueue
);
1991 typedef VkResult (VKAPI
*PFN_vkQueueSubmit
)(VkQueue queue
, uint32_t cmdBufferCount
, const VkCmdBuffer
* pCmdBuffers
, VkFence fence
);
1992 typedef VkResult (VKAPI
*PFN_vkQueueWaitIdle
)(VkQueue queue
);
1993 typedef VkResult (VKAPI
*PFN_vkDeviceWaitIdle
)(VkDevice device
);
1994 typedef VkResult (VKAPI
*PFN_vkAllocMemory
)(VkDevice device
, const VkMemoryAllocInfo
* pAllocInfo
, VkDeviceMemory
* pMem
);
1995 typedef VkResult (VKAPI
*PFN_vkFreeMemory
)(VkDevice device
, VkDeviceMemory mem
);
1996 typedef VkResult (VKAPI
*PFN_vkMapMemory
)(VkDevice device
, VkDeviceMemory mem
, VkDeviceSize offset
, VkDeviceSize size
, VkMemoryMapFlags flags
, void** ppData
);
1997 typedef VkResult (VKAPI
*PFN_vkUnmapMemory
)(VkDevice device
, VkDeviceMemory mem
);
1998 typedef VkResult (VKAPI
*PFN_vkFlushMappedMemory
)(VkDevice device
, VkDeviceMemory mem
, VkDeviceSize offset
, VkDeviceSize size
);
1999 typedef VkResult (VKAPI
*PFN_vkPinSystemMemory
)(VkDevice device
, const void* pSysMem
, size_t memSize
, VkDeviceMemory
* pMem
);
2000 typedef VkResult (VKAPI
*PFN_vkGetMultiDeviceCompatibility
)(VkPhysicalDevice physicalDevice0
, VkPhysicalDevice physicalDevice1
, VkPhysicalDeviceCompatibilityInfo
* pInfo
);
2001 typedef VkResult (VKAPI
*PFN_vkOpenSharedMemory
)(VkDevice device
, const VkMemoryOpenInfo
* pOpenInfo
, VkDeviceMemory
* pMem
);
2002 typedef VkResult (VKAPI
*PFN_vkOpenSharedSemaphore
)(VkDevice device
, const VkSemaphoreOpenInfo
* pOpenInfo
, VkSemaphore
* pSemaphore
);
2003 typedef VkResult (VKAPI
*PFN_vkOpenPeerMemory
)(VkDevice device
, const VkPeerMemoryOpenInfo
* pOpenInfo
, VkDeviceMemory
* pMem
);
2004 typedef VkResult (VKAPI
*PFN_vkOpenPeerImage
)(VkDevice device
, const VkPeerImageOpenInfo
* pOpenInfo
, VkImage
* pImage
, VkDeviceMemory
* pMem
);
2005 typedef VkResult (VKAPI
*PFN_vkDestroyObject
)(VkDevice device
, VkObjectType objType
, VkObject object
);
2006 typedef VkResult (VKAPI
*PFN_vkGetObjectInfo
)(VkDevice device
, VkObjectType objType
, VkObject object
, VkObjectInfoType infoType
, size_t* pDataSize
, void* pData
);
2007 typedef VkResult (VKAPI
*PFN_vkQueueBindObjectMemory
)(VkQueue queue
, VkObjectType objType
, VkObject object
, uint32_t allocationIdx
, VkDeviceMemory mem
, VkDeviceSize offset
);
2008 typedef VkResult (VKAPI
*PFN_vkQueueBindObjectMemoryRange
)(VkQueue queue
, VkObjectType objType
, VkObject object
, uint32_t allocationIdx
, VkDeviceSize rangeOffset
, VkDeviceSize rangeSize
, VkDeviceMemory mem
, VkDeviceSize memOffset
);
2009 typedef VkResult (VKAPI
*PFN_vkQueueBindImageMemoryRange
)(VkQueue queue
, VkImage image
, uint32_t allocationIdx
, const VkImageMemoryBindInfo
* pBindInfo
, VkDeviceMemory mem
, VkDeviceSize memOffset
);
2010 typedef VkResult (VKAPI
*PFN_vkCreateFence
)(VkDevice device
, const VkFenceCreateInfo
* pCreateInfo
, VkFence
* pFence
);
2011 typedef VkResult (VKAPI
*PFN_vkResetFences
)(VkDevice device
, uint32_t fenceCount
, VkFence
* pFences
);
2012 typedef VkResult (VKAPI
*PFN_vkGetFenceStatus
)(VkDevice device
, VkFence fence
);
2013 typedef VkResult (VKAPI
*PFN_vkWaitForFences
)(VkDevice device
, uint32_t fenceCount
, const VkFence
* pFences
, bool32_t waitAll
, uint64_t timeout
);
2014 typedef VkResult (VKAPI
*PFN_vkCreateSemaphore
)(VkDevice device
, const VkSemaphoreCreateInfo
* pCreateInfo
, VkSemaphore
* pSemaphore
);
2015 typedef VkResult (VKAPI
*PFN_vkQueueSignalSemaphore
)(VkQueue queue
, VkSemaphore semaphore
);
2016 typedef VkResult (VKAPI
*PFN_vkQueueWaitSemaphore
)(VkQueue queue
, VkSemaphore semaphore
);
2017 typedef VkResult (VKAPI
*PFN_vkCreateEvent
)(VkDevice device
, const VkEventCreateInfo
* pCreateInfo
, VkEvent
* pEvent
);
2018 typedef VkResult (VKAPI
*PFN_vkGetEventStatus
)(VkDevice device
, VkEvent event
);
2019 typedef VkResult (VKAPI
*PFN_vkSetEvent
)(VkDevice device
, VkEvent event
);
2020 typedef VkResult (VKAPI
*PFN_vkResetEvent
)(VkDevice device
, VkEvent event
);
2021 typedef VkResult (VKAPI
*PFN_vkCreateQueryPool
)(VkDevice device
, const VkQueryPoolCreateInfo
* pCreateInfo
, VkQueryPool
* pQueryPool
);
2022 typedef VkResult (VKAPI
*PFN_vkGetQueryPoolResults
)(VkDevice device
, VkQueryPool queryPool
, uint32_t startQuery
, uint32_t queryCount
, size_t* pDataSize
, void* pData
, VkQueryResultFlags flags
);
2023 typedef VkResult (VKAPI
*PFN_vkGetFormatInfo
)(VkDevice device
, VkFormat format
, VkFormatInfoType infoType
, size_t* pDataSize
, void* pData
);
2024 typedef VkResult (VKAPI
*PFN_vkCreateBuffer
)(VkDevice device
, const VkBufferCreateInfo
* pCreateInfo
, VkBuffer
* pBuffer
);
2025 typedef VkResult (VKAPI
*PFN_vkCreateBufferView
)(VkDevice device
, const VkBufferViewCreateInfo
* pCreateInfo
, VkBufferView
* pView
);
2026 typedef VkResult (VKAPI
*PFN_vkCreateImage
)(VkDevice device
, const VkImageCreateInfo
* pCreateInfo
, VkImage
* pImage
);
2027 typedef VkResult (VKAPI
*PFN_vkGetImageSubresourceInfo
)(VkDevice device
, VkImage image
, const VkImageSubresource
* pSubresource
, VkSubresourceInfoType infoType
, size_t* pDataSize
, void* pData
);
2028 typedef VkResult (VKAPI
*PFN_vkCreateImageView
)(VkDevice device
, const VkImageViewCreateInfo
* pCreateInfo
, VkImageView
* pView
);
2029 typedef VkResult (VKAPI
*PFN_vkCreateColorAttachmentView
)(VkDevice device
, const VkColorAttachmentViewCreateInfo
* pCreateInfo
, VkColorAttachmentView
* pView
);
2030 typedef VkResult (VKAPI
*PFN_vkCreateDepthStencilView
)(VkDevice device
, const VkDepthStencilViewCreateInfo
* pCreateInfo
, VkDepthStencilView
* pView
);
2031 typedef VkResult (VKAPI
*PFN_vkCreateShader
)(VkDevice device
, const VkShaderCreateInfo
* pCreateInfo
, VkShader
* pShader
);
2032 typedef VkResult (VKAPI
*PFN_vkCreateGraphicsPipeline
)(VkDevice device
, const VkGraphicsPipelineCreateInfo
* pCreateInfo
, VkPipeline
* pPipeline
);
2033 typedef VkResult (VKAPI
*PFN_vkCreateGraphicsPipelineDerivative
)(VkDevice device
, const VkGraphicsPipelineCreateInfo
* pCreateInfo
, VkPipeline basePipeline
, VkPipeline
* pPipeline
);
2034 typedef VkResult (VKAPI
*PFN_vkCreateComputePipeline
)(VkDevice device
, const VkComputePipelineCreateInfo
* pCreateInfo
, VkPipeline
* pPipeline
);
2035 typedef VkResult (VKAPI
*PFN_vkStorePipeline
)(VkDevice device
, VkPipeline pipeline
, size_t* pDataSize
, void* pData
);
2036 typedef VkResult (VKAPI
*PFN_vkLoadPipeline
)(VkDevice device
, size_t dataSize
, const void* pData
, VkPipeline
* pPipeline
);
2037 typedef VkResult (VKAPI
*PFN_vkLoadPipelineDerivative
)(VkDevice device
, size_t dataSize
, const void* pData
, VkPipeline basePipeline
, VkPipeline
* pPipeline
);
2038 typedef VkResult (VKAPI
*PFN_vkCreatePipelineLayout
)(VkDevice device
, const VkPipelineLayoutCreateInfo
* pCreateInfo
, VkPipelineLayout
* pPipelineLayout
);
2039 typedef VkResult (VKAPI
*PFN_vkCreateSampler
)(VkDevice device
, const VkSamplerCreateInfo
* pCreateInfo
, VkSampler
* pSampler
);
2040 typedef VkResult (VKAPI
*PFN_vkCreateDescriptorSetLayout
)(VkDevice device
, const VkDescriptorSetLayoutCreateInfo
* pCreateInfo
, VkDescriptorSetLayout
* pSetLayout
);
2041 typedef VkResult (VKAPI
*PFN_vkCreateDescriptorPool
)(VkDevice device
, VkDescriptorPoolUsage poolUsage
, uint32_t maxSets
, const VkDescriptorPoolCreateInfo
* pCreateInfo
, VkDescriptorPool
* pDescriptorPool
);
2042 typedef VkResult (VKAPI
*PFN_vkResetDescriptorPool
)(VkDevice device
, VkDescriptorPool descriptorPool
);
2043 typedef VkResult (VKAPI
*PFN_vkAllocDescriptorSets
)(VkDevice device
, VkDescriptorPool descriptorPool
, VkDescriptorSetUsage setUsage
, uint32_t count
, const VkDescriptorSetLayout
* pSetLayouts
, VkDescriptorSet
* pDescriptorSets
, uint32_t* pCount
);
2044 typedef void (VKAPI
*PFN_vkClearDescriptorSets
)(VkDevice device
, VkDescriptorPool descriptorPool
, uint32_t count
, const VkDescriptorSet
* pDescriptorSets
);
2045 typedef void (VKAPI
*PFN_vkUpdateDescriptors
)(VkDevice device
, VkDescriptorSet descriptorSet
, uint32_t updateCount
, const void** ppUpdateArray
);
2046 typedef VkResult (VKAPI
*PFN_vkCreateDynamicViewportState
)(VkDevice device
, const VkDynamicVpStateCreateInfo
* pCreateInfo
, VkDynamicVpState
* pState
);
2047 typedef VkResult (VKAPI
*PFN_vkCreateDynamicRasterState
)(VkDevice device
, const VkDynamicRsStateCreateInfo
* pCreateInfo
, VkDynamicRsState
* pState
);
2048 typedef VkResult (VKAPI
*PFN_vkCreateDynamicColorBlendState
)(VkDevice device
, const VkDynamicCbStateCreateInfo
* pCreateInfo
, VkDynamicCbState
* pState
);
2049 typedef VkResult (VKAPI
*PFN_vkCreateDynamicDepthStencilState
)(VkDevice device
, const VkDynamicDsStateCreateInfo
* pCreateInfo
, VkDynamicDsState
* pState
);
2050 typedef VkResult (VKAPI
*PFN_vkCreateCommandBuffer
)(VkDevice device
, const VkCmdBufferCreateInfo
* pCreateInfo
, VkCmdBuffer
* pCmdBuffer
);
2051 typedef VkResult (VKAPI
*PFN_vkBeginCommandBuffer
)(VkCmdBuffer cmdBuffer
, const VkCmdBufferBeginInfo
* pBeginInfo
);
2052 typedef VkResult (VKAPI
*PFN_vkEndCommandBuffer
)(VkCmdBuffer cmdBuffer
);
2053 typedef VkResult (VKAPI
*PFN_vkResetCommandBuffer
)(VkCmdBuffer cmdBuffer
);
2054 typedef void (VKAPI
*PFN_vkCmdBindPipeline
)(VkCmdBuffer cmdBuffer
, VkPipelineBindPoint pipelineBindPoint
, VkPipeline pipeline
);
2055 typedef void (VKAPI
*PFN_vkCmdBindDynamicStateObject
)(VkCmdBuffer cmdBuffer
, VkStateBindPoint stateBindPoint
, VkDynamicStateObject state
);
2056 typedef void (VKAPI
*PFN_vkCmdBindDescriptorSets
)(VkCmdBuffer cmdBuffer
, VkPipelineBindPoint pipelineBindPoint
, uint32_t firstSet
, uint32_t setCount
, const VkDescriptorSet
* pDescriptorSets
, uint32_t dynamicOffsetCount
, const uint32_t* pDynamicOffsets
);
2057 typedef void (VKAPI
*PFN_vkCmdBindIndexBuffer
)(VkCmdBuffer cmdBuffer
, VkBuffer buffer
, VkDeviceSize offset
, VkIndexType indexType
);
2058 typedef void (VKAPI
*PFN_vkCmdBindVertexBuffers
)(VkCmdBuffer cmdBuffer
, uint32_t startBinding
, uint32_t bindingCount
, const VkBuffer
* pBuffers
, const VkDeviceSize
* pOffsets
);
2059 typedef void (VKAPI
*PFN_vkCmdDraw
)(VkCmdBuffer cmdBuffer
, uint32_t firstVertex
, uint32_t vertexCount
, uint32_t firstInstance
, uint32_t instanceCount
);
2060 typedef void (VKAPI
*PFN_vkCmdDrawIndexed
)(VkCmdBuffer cmdBuffer
, uint32_t firstIndex
, uint32_t indexCount
, int32_t vertexOffset
, uint32_t firstInstance
, uint32_t instanceCount
);
2061 typedef void (VKAPI
*PFN_vkCmdDrawIndirect
)(VkCmdBuffer cmdBuffer
, VkBuffer buffer
, VkDeviceSize offset
, uint32_t count
, uint32_t stride
);
2062 typedef void (VKAPI
*PFN_vkCmdDrawIndexedIndirect
)(VkCmdBuffer cmdBuffer
, VkBuffer buffer
, VkDeviceSize offset
, uint32_t count
, uint32_t stride
);
2063 typedef void (VKAPI
*PFN_vkCmdDispatch
)(VkCmdBuffer cmdBuffer
, uint32_t x
, uint32_t y
, uint32_t z
);
2064 typedef void (VKAPI
*PFN_vkCmdDispatchIndirect
)(VkCmdBuffer cmdBuffer
, VkBuffer buffer
, VkDeviceSize offset
);
2065 typedef void (VKAPI
*PFN_vkCmdCopyBuffer
)(VkCmdBuffer cmdBuffer
, VkBuffer srcBuffer
, VkBuffer destBuffer
, uint32_t regionCount
, const VkBufferCopy
* pRegions
);
2066 typedef void (VKAPI
*PFN_vkCmdCopyImage
)(VkCmdBuffer cmdBuffer
, VkImage srcImage
, VkImageLayout srcImageLayout
, VkImage destImage
, VkImageLayout destImageLayout
, uint32_t regionCount
, const VkImageCopy
* pRegions
);
2067 typedef void (VKAPI
*PFN_vkCmdBlitImage
)(VkCmdBuffer cmdBuffer
, VkImage srcImage
, VkImageLayout srcImageLayout
, VkImage destImage
, VkImageLayout destImageLayout
, uint32_t regionCount
, const VkImageBlit
* pRegions
);
2068 typedef void (VKAPI
*PFN_vkCmdCopyBufferToImage
)(VkCmdBuffer cmdBuffer
, VkBuffer srcBuffer
, VkImage destImage
, VkImageLayout destImageLayout
, uint32_t regionCount
, const VkBufferImageCopy
* pRegions
);
2069 typedef void (VKAPI
*PFN_vkCmdCopyImageToBuffer
)(VkCmdBuffer cmdBuffer
, VkImage srcImage
, VkImageLayout srcImageLayout
, VkBuffer destBuffer
, uint32_t regionCount
, const VkBufferImageCopy
* pRegions
);
2070 typedef void (VKAPI
*PFN_vkCmdUpdateBuffer
)(VkCmdBuffer cmdBuffer
, VkBuffer destBuffer
, VkDeviceSize destOffset
, VkDeviceSize dataSize
, const uint32_t* pData
);
2071 typedef void (VKAPI
*PFN_vkCmdFillBuffer
)(VkCmdBuffer cmdBuffer
, VkBuffer destBuffer
, VkDeviceSize destOffset
, VkDeviceSize fillSize
, uint32_t data
);
2072 typedef void (VKAPI
*PFN_vkCmdClearColorImage
)(VkCmdBuffer cmdBuffer
, VkImage image
, VkImageLayout imageLayout
, VkClearColor color
, uint32_t rangeCount
, const VkImageSubresourceRange
* pRanges
);
2073 typedef void (VKAPI
*PFN_vkCmdClearDepthStencil
)(VkCmdBuffer cmdBuffer
, VkImage image
, VkImageLayout imageLayout
, float depth
, uint32_t stencil
, uint32_t rangeCount
, const VkImageSubresourceRange
* pRanges
);
2074 typedef void (VKAPI
*PFN_vkCmdResolveImage
)(VkCmdBuffer cmdBuffer
, VkImage srcImage
, VkImageLayout srcImageLayout
, VkImage destImage
, VkImageLayout destImageLayout
, uint32_t regionCount
, const VkImageResolve
* pRegions
);
2075 typedef void (VKAPI
*PFN_vkCmdSetEvent
)(VkCmdBuffer cmdBuffer
, VkEvent event
, VkPipeEvent pipeEvent
);
2076 typedef void (VKAPI
*PFN_vkCmdResetEvent
)(VkCmdBuffer cmdBuffer
, VkEvent event
, VkPipeEvent pipeEvent
);
2077 typedef void (VKAPI
*PFN_vkCmdWaitEvents
)(VkCmdBuffer cmdBuffer
, VkWaitEvent waitEvent
, uint32_t eventCount
, const VkEvent
* pEvents
, uint32_t memBarrierCount
, const void** ppMemBarriers
);
2078 typedef void (VKAPI
*PFN_vkCmdPipelineBarrier
)(VkCmdBuffer cmdBuffer
, VkWaitEvent waitEvent
, uint32_t pipeEventCount
, const VkPipeEvent
* pPipeEvents
, uint32_t memBarrierCount
, const void** ppMemBarriers
);
2079 typedef void (VKAPI
*PFN_vkCmdBeginQuery
)(VkCmdBuffer cmdBuffer
, VkQueryPool queryPool
, uint32_t slot
, VkQueryControlFlags flags
);
2080 typedef void (VKAPI
*PFN_vkCmdEndQuery
)(VkCmdBuffer cmdBuffer
, VkQueryPool queryPool
, uint32_t slot
);
2081 typedef void (VKAPI
*PFN_vkCmdResetQueryPool
)(VkCmdBuffer cmdBuffer
, VkQueryPool queryPool
, uint32_t startQuery
, uint32_t queryCount
);
2082 typedef void (VKAPI
*PFN_vkCmdWriteTimestamp
)(VkCmdBuffer cmdBuffer
, VkTimestampType timestampType
, VkBuffer destBuffer
, VkDeviceSize destOffset
);
2083 typedef void (VKAPI
*PFN_vkCmdCopyQueryPoolResults
)(VkCmdBuffer cmdBuffer
, VkQueryPool queryPool
, uint32_t startQuery
, uint32_t queryCount
, VkBuffer destBuffer
, VkDeviceSize destOffset
, VkDeviceSize destStride
, VkQueryResultFlags flags
);
2084 typedef VkResult (VKAPI
*PFN_vkCreateFramebuffer
)(VkDevice device
, const VkFramebufferCreateInfo
* pCreateInfo
, VkFramebuffer
* pFramebuffer
);
2085 typedef VkResult (VKAPI
*PFN_vkCreateRenderPass
)(VkDevice device
, const VkRenderPassCreateInfo
* pCreateInfo
, VkRenderPass
* pRenderPass
);
2086 typedef void (VKAPI
*PFN_vkCmdBeginRenderPass
)(VkCmdBuffer cmdBuffer
, const VkRenderPassBegin
* pRenderPassBegin
);
2087 typedef void (VKAPI
*PFN_vkCmdEndRenderPass
)(VkCmdBuffer cmdBuffer
, VkRenderPass renderPass
);
2089 #ifdef VK_PROTOTYPES
2090 VkResult VKAPI
vkCreateInstance(
2091 const VkInstanceCreateInfo
* pCreateInfo
,
2092 VkInstance
* pInstance
);
2094 VkResult VKAPI
vkDestroyInstance(
2095 VkInstance instance
);
2097 VkResult VKAPI
vkEnumeratePhysicalDevices(
2098 VkInstance instance
,
2099 uint32_t* pPhysicalDeviceCount
,
2100 VkPhysicalDevice
* pPhysicalDevices
);
2102 VkResult VKAPI
vkGetPhysicalDeviceInfo(
2103 VkPhysicalDevice physicalDevice
,
2104 VkPhysicalDeviceInfoType infoType
,
2108 void * VKAPI
vkGetProcAddr(
2109 VkPhysicalDevice physicalDevice
,
2114 VkResult VKAPI
vkCreateDevice(
2115 VkPhysicalDevice physicalDevice
,
2116 const VkDeviceCreateInfo
* pCreateInfo
,
2119 VkResult VKAPI
vkDestroyDevice(
2122 VkResult VKAPI
vkGetGlobalExtensionInfo(
2123 VkExtensionInfoType infoType
,
2124 uint32_t extensionIndex
,
2128 VkResult VKAPI
vkGetPhysicalDeviceExtensionInfo(
2129 VkPhysicalDevice physicalDevice
,
2130 VkExtensionInfoType infoType
,
2131 uint32_t extensionIndex
,
2135 VkResult VKAPI
vkEnumerateLayers(
2136 VkPhysicalDevice physicalDevice
,
2137 size_t maxStringSize
,
2138 size_t* pLayerCount
,
2139 char* const* pOutLayers
,
2142 VkResult VKAPI
vkGetDeviceQueue(
2144 uint32_t queueNodeIndex
,
2145 uint32_t queueIndex
,
2148 VkResult VKAPI
vkQueueSubmit(
2150 uint32_t cmdBufferCount
,
2151 const VkCmdBuffer
* pCmdBuffers
,
2154 VkResult VKAPI
vkQueueWaitIdle(
2157 VkResult VKAPI
vkDeviceWaitIdle(
2160 VkResult VKAPI
vkAllocMemory(
2162 const VkMemoryAllocInfo
* pAllocInfo
,
2163 VkDeviceMemory
* pMem
);
2165 VkResult VKAPI
vkFreeMemory(
2167 VkDeviceMemory mem
);
2169 VkResult VKAPI
vkMapMemory(
2172 VkDeviceSize offset
,
2174 VkMemoryMapFlags flags
,
2177 VkResult VKAPI
vkUnmapMemory(
2179 VkDeviceMemory mem
);
2181 VkResult VKAPI
vkFlushMappedMemory(
2184 VkDeviceSize offset
,
2187 VkResult VKAPI
vkPinSystemMemory(
2189 const void* pSysMem
,
2191 VkDeviceMemory
* pMem
);
2193 VkResult VKAPI
vkGetMultiDeviceCompatibility(
2194 VkPhysicalDevice physicalDevice0
,
2195 VkPhysicalDevice physicalDevice1
,
2196 VkPhysicalDeviceCompatibilityInfo
* pInfo
);
2198 VkResult VKAPI
vkOpenSharedMemory(
2200 const VkMemoryOpenInfo
* pOpenInfo
,
2201 VkDeviceMemory
* pMem
);
2203 VkResult VKAPI
vkOpenSharedSemaphore(
2205 const VkSemaphoreOpenInfo
* pOpenInfo
,
2206 VkSemaphore
* pSemaphore
);
2208 VkResult VKAPI
vkOpenPeerMemory(
2210 const VkPeerMemoryOpenInfo
* pOpenInfo
,
2211 VkDeviceMemory
* pMem
);
2213 VkResult VKAPI
vkOpenPeerImage(
2215 const VkPeerImageOpenInfo
* pOpenInfo
,
2217 VkDeviceMemory
* pMem
);
2219 VkResult VKAPI
vkDestroyObject(
2221 VkObjectType objType
,
2224 VkResult VKAPI
vkGetObjectInfo(
2226 VkObjectType objType
,
2228 VkObjectInfoType infoType
,
2232 VkResult VKAPI
vkQueueBindObjectMemory(
2234 VkObjectType objType
,
2236 uint32_t allocationIdx
,
2238 VkDeviceSize memOffset
);
2240 VkResult VKAPI
vkQueueBindObjectMemoryRange(
2242 VkObjectType objType
,
2244 uint32_t allocationIdx
,
2245 VkDeviceSize rangeOffset
,
2246 VkDeviceSize rangeSize
,
2248 VkDeviceSize memOffset
);
2250 VkResult VKAPI
vkQueueBindImageMemoryRange(
2253 uint32_t allocationIdx
,
2254 const VkImageMemoryBindInfo
* pBindInfo
,
2256 VkDeviceSize memOffset
);
2258 VkResult VKAPI
vkCreateFence(
2260 const VkFenceCreateInfo
* pCreateInfo
,
2263 VkResult VKAPI
vkResetFences(
2265 uint32_t fenceCount
,
2268 VkResult VKAPI
vkGetFenceStatus(
2272 VkResult VKAPI
vkWaitForFences(
2274 uint32_t fenceCount
,
2275 const VkFence
* pFences
,
2277 uint64_t timeout
); // timeout in nanoseconds
2279 VkResult VKAPI
vkCreateSemaphore(
2281 const VkSemaphoreCreateInfo
* pCreateInfo
,
2282 VkSemaphore
* pSemaphore
);
2284 VkResult VKAPI
vkQueueSignalSemaphore(
2286 VkSemaphore semaphore
);
2288 VkResult VKAPI
vkQueueWaitSemaphore(
2290 VkSemaphore semaphore
);
2292 VkResult VKAPI
vkCreateEvent(
2294 const VkEventCreateInfo
* pCreateInfo
,
2297 VkResult VKAPI
vkGetEventStatus(
2301 VkResult VKAPI
vkSetEvent(
2305 VkResult VKAPI
vkResetEvent(
2309 VkResult VKAPI
vkCreateQueryPool(
2311 const VkQueryPoolCreateInfo
* pCreateInfo
,
2312 VkQueryPool
* pQueryPool
);
2314 VkResult VKAPI
vkGetQueryPoolResults(
2316 VkQueryPool queryPool
,
2317 uint32_t startQuery
,
2318 uint32_t queryCount
,
2321 VkQueryResultFlags flags
);
2323 VkResult VKAPI
vkGetFormatInfo(
2326 VkFormatInfoType infoType
,
2330 VkResult VKAPI
vkCreateBuffer(
2332 const VkBufferCreateInfo
* pCreateInfo
,
2335 VkResult VKAPI
vkCreateBufferView(
2337 const VkBufferViewCreateInfo
* pCreateInfo
,
2338 VkBufferView
* pView
);
2340 VkResult VKAPI
vkCreateImage(
2342 const VkImageCreateInfo
* pCreateInfo
,
2345 VkResult VKAPI
vkGetImageSubresourceInfo(
2348 const VkImageSubresource
* pSubresource
,
2349 VkSubresourceInfoType infoType
,
2353 // Image view functions
2355 VkResult VKAPI
vkCreateImageView(
2357 const VkImageViewCreateInfo
* pCreateInfo
,
2358 VkImageView
* pView
);
2360 VkResult VKAPI
vkCreateColorAttachmentView(
2362 const VkColorAttachmentViewCreateInfo
* pCreateInfo
,
2363 VkColorAttachmentView
* pView
);
2365 VkResult VKAPI
vkCreateDepthStencilView(
2367 const VkDepthStencilViewCreateInfo
* pCreateInfo
,
2368 VkDepthStencilView
* pView
);
2370 VkResult VKAPI
vkCreateShader(
2372 const VkShaderCreateInfo
* pCreateInfo
,
2375 VkResult VKAPI
vkCreateGraphicsPipeline(
2377 const VkGraphicsPipelineCreateInfo
* pCreateInfo
,
2378 VkPipeline
* pPipeline
);
2380 VkResult VKAPI
vkCreateGraphicsPipelineDerivative(
2382 const VkGraphicsPipelineCreateInfo
* pCreateInfo
,
2383 VkPipeline basePipeline
,
2384 VkPipeline
* pPipeline
);
2386 VkResult VKAPI
vkCreateComputePipeline(
2388 const VkComputePipelineCreateInfo
* pCreateInfo
,
2389 VkPipeline
* pPipeline
);
2391 VkResult VKAPI
vkStorePipeline(
2393 VkPipeline pipeline
,
2397 VkResult VKAPI
vkLoadPipeline(
2401 VkPipeline
* pPipeline
);
2403 VkResult VKAPI
vkLoadPipelineDerivative(
2407 VkPipeline basePipeline
,
2408 VkPipeline
* pPipeline
);
2410 VkResult VKAPI
vkCreatePipelineLayout(
2412 const VkPipelineLayoutCreateInfo
* pCreateInfo
,
2413 VkPipelineLayout
* pPipelineLayout
);
2415 VkResult VKAPI
vkCreateSampler(
2417 const VkSamplerCreateInfo
* pCreateInfo
,
2418 VkSampler
* pSampler
);
2420 VkResult VKAPI
vkCreateDescriptorSetLayout(
2422 const VkDescriptorSetLayoutCreateInfo
* pCreateInfo
,
2423 VkDescriptorSetLayout
* pSetLayout
);
2425 VkResult VKAPI
vkCreateDescriptorPool(
2427 VkDescriptorPoolUsage poolUsage
,
2429 const VkDescriptorPoolCreateInfo
* pCreateInfo
,
2430 VkDescriptorPool
* pDescriptorPool
);
2432 VkResult VKAPI
vkResetDescriptorPool(
2434 VkDescriptorPool descriptorPool
);
2436 VkResult VKAPI
vkAllocDescriptorSets(
2438 VkDescriptorPool descriptorPool
,
2439 VkDescriptorSetUsage setUsage
,
2441 const VkDescriptorSetLayout
* pSetLayouts
,
2442 VkDescriptorSet
* pDescriptorSets
,
2445 void VKAPI
vkClearDescriptorSets(
2447 VkDescriptorPool descriptorPool
,
2449 const VkDescriptorSet
* pDescriptorSets
);
2451 void VKAPI
vkUpdateDescriptors(
2453 VkDescriptorSet descriptorSet
,
2454 uint32_t updateCount
,
2455 const void** ppUpdateArray
);
2457 VkResult VKAPI
vkCreateDynamicViewportState(
2459 const VkDynamicVpStateCreateInfo
* pCreateInfo
,
2460 VkDynamicVpState
* pState
);
2462 VkResult VKAPI
vkCreateDynamicRasterState(
2464 const VkDynamicRsStateCreateInfo
* pCreateInfo
,
2465 VkDynamicRsState
* pState
);
2467 VkResult VKAPI
vkCreateDynamicColorBlendState(
2469 const VkDynamicCbStateCreateInfo
* pCreateInfo
,
2470 VkDynamicCbState
* pState
);
2472 VkResult VKAPI
vkCreateDynamicDepthStencilState(
2474 const VkDynamicDsStateCreateInfo
* pCreateInfo
,
2475 VkDynamicDsState
* pState
);
2477 VkResult VKAPI
vkCreateFramebuffer(
2479 const VkFramebufferCreateInfo
* pCreateInfo
,
2480 VkFramebuffer
* pFramebuffer
);
2482 VkResult VKAPI
vkCreateRenderPass(
2484 const VkRenderPassCreateInfo
* pCreateInfo
,
2485 VkRenderPass
* pRenderPass
);
2487 VkResult VKAPI
vkCreateCommandBuffer(
2489 const VkCmdBufferCreateInfo
* pCreateInfo
,
2490 VkCmdBuffer
* pCmdBuffer
);
2492 VkResult VKAPI
vkBeginCommandBuffer(
2493 VkCmdBuffer cmdBuffer
,
2494 const VkCmdBufferBeginInfo
* pBeginInfo
);
2496 VkResult VKAPI
vkEndCommandBuffer(
2497 VkCmdBuffer cmdBuffer
);
2499 VkResult VKAPI
vkResetCommandBuffer(
2500 VkCmdBuffer cmdBuffer
);
2502 void VKAPI
vkCmdBindPipeline(
2503 VkCmdBuffer cmdBuffer
,
2504 VkPipelineBindPoint pipelineBindPoint
,
2505 VkPipeline pipeline
);
2507 void VKAPI
vkCmdBindDynamicStateObject(
2508 VkCmdBuffer cmdBuffer
,
2509 VkStateBindPoint stateBindPoint
,
2510 VkDynamicStateObject dynamicState
);
2512 void VKAPI
vkCmdBindDescriptorSets(
2513 VkCmdBuffer cmdBuffer
,
2514 VkPipelineBindPoint pipelineBindPoint
,
2517 const VkDescriptorSet
* pDescriptorSets
,
2518 uint32_t dynamicOffsetCount
,
2519 const uint32_t* pDynamicOffsets
);
2521 void VKAPI
vkCmdBindIndexBuffer(
2522 VkCmdBuffer cmdBuffer
,
2524 VkDeviceSize offset
,
2525 VkIndexType indexType
);
2527 void VKAPI
vkCmdBindVertexBuffers(
2528 VkCmdBuffer cmdBuffer
,
2529 uint32_t startBinding
,
2530 uint32_t bindingCount
,
2531 const VkBuffer
* pBuffers
,
2532 const VkDeviceSize
* pOffsets
);
2534 void VKAPI
vkCmdDraw(
2535 VkCmdBuffer cmdBuffer
,
2536 uint32_t firstVertex
,
2537 uint32_t vertexCount
,
2538 uint32_t firstInstance
,
2539 uint32_t instanceCount
);
2541 void VKAPI
vkCmdDrawIndexed(
2542 VkCmdBuffer cmdBuffer
,
2543 uint32_t firstIndex
,
2544 uint32_t indexCount
,
2545 int32_t vertexOffset
,
2546 uint32_t firstInstance
,
2547 uint32_t instanceCount
);
2549 void VKAPI
vkCmdDrawIndirect(
2550 VkCmdBuffer cmdBuffer
,
2552 VkDeviceSize offset
,
2556 void VKAPI
vkCmdDrawIndexedIndirect(
2557 VkCmdBuffer cmdBuffer
,
2559 VkDeviceSize offset
,
2563 void VKAPI
vkCmdDispatch(
2564 VkCmdBuffer cmdBuffer
,
2569 void VKAPI
vkCmdDispatchIndirect(
2570 VkCmdBuffer cmdBuffer
,
2572 VkDeviceSize offset
);
2574 void VKAPI
vkCmdCopyBuffer(
2575 VkCmdBuffer cmdBuffer
,
2577 VkBuffer destBuffer
,
2578 uint32_t regionCount
,
2579 const VkBufferCopy
* pRegions
);
2581 void VKAPI
vkCmdCopyImage(
2582 VkCmdBuffer cmdBuffer
,
2584 VkImageLayout srcImageLayout
,
2586 VkImageLayout destImageLayout
,
2587 uint32_t regionCount
,
2588 const VkImageCopy
* pRegions
);
2590 void VKAPI
vkCmdBlitImage(
2591 VkCmdBuffer cmdBuffer
,
2593 VkImageLayout srcImageLayout
,
2595 VkImageLayout destImageLayout
,
2596 uint32_t regionCount
,
2597 const VkImageBlit
* pRegions
);
2599 void VKAPI
vkCmdCopyBufferToImage(
2600 VkCmdBuffer cmdBuffer
,
2603 VkImageLayout destImageLayout
,
2604 uint32_t regionCount
,
2605 const VkBufferImageCopy
* pRegions
);
2607 void VKAPI
vkCmdCopyImageToBuffer(
2608 VkCmdBuffer cmdBuffer
,
2610 VkImageLayout srcImageLayout
,
2611 VkBuffer destBuffer
,
2612 uint32_t regionCount
,
2613 const VkBufferImageCopy
* pRegions
);
2615 void VKAPI
vkCmdUpdateBuffer(
2616 VkCmdBuffer cmdBuffer
,
2617 VkBuffer destBuffer
,
2618 VkDeviceSize destOffset
,
2619 VkDeviceSize dataSize
,
2620 const uint32_t* pData
);
2622 void VKAPI
vkCmdFillBuffer(
2623 VkCmdBuffer cmdBuffer
,
2624 VkBuffer destBuffer
,
2625 VkDeviceSize destOffset
,
2626 VkDeviceSize fillSize
,
2629 void VKAPI
vkCmdClearColorImage(
2630 VkCmdBuffer cmdBuffer
,
2632 VkImageLayout imageLayout
,
2634 uint32_t rangeCount
,
2635 const VkImageSubresourceRange
* pRanges
);
2637 void VKAPI
vkCmdClearDepthStencil(
2638 VkCmdBuffer cmdBuffer
,
2640 VkImageLayout imageLayout
,
2643 uint32_t rangeCount
,
2644 const VkImageSubresourceRange
* pRanges
);
2646 void VKAPI
vkCmdResolveImage(
2647 VkCmdBuffer cmdBuffer
,
2649 VkImageLayout srcImageLayout
,
2651 VkImageLayout destImageLayout
,
2652 uint32_t regionCount
,
2653 const VkImageResolve
* pRegions
);
2655 void VKAPI
vkCmdSetEvent(
2656 VkCmdBuffer cmdBuffer
,
2658 VkPipeEvent pipeEvent
);
2660 void VKAPI
vkCmdResetEvent(
2661 VkCmdBuffer cmdBuffer
,
2663 VkPipeEvent pipeEvent
);
2665 void VKAPI
vkCmdWaitEvents(
2666 VkCmdBuffer cmdBuffer
,
2667 VkWaitEvent waitEvent
,
2668 uint32_t eventCount
,
2669 const VkEvent
* pEvents
,
2670 uint32_t memBarrierCount
,
2671 const void** ppMemBarriers
);
2673 void VKAPI
vkCmdPipelineBarrier(
2674 VkCmdBuffer cmdBuffer
,
2675 VkWaitEvent waitEvent
,
2676 uint32_t pipeEventCount
,
2677 const VkPipeEvent
* pPipeEvents
,
2678 uint32_t memBarrierCount
,
2679 const void** ppMemBarriers
);
2681 void VKAPI
vkCmdBeginQuery(
2682 VkCmdBuffer cmdBuffer
,
2683 VkQueryPool queryPool
,
2685 VkQueryControlFlags flags
);
2687 void VKAPI
vkCmdEndQuery(
2688 VkCmdBuffer cmdBuffer
,
2689 VkQueryPool queryPool
,
2692 void VKAPI
vkCmdResetQueryPool(
2693 VkCmdBuffer cmdBuffer
,
2694 VkQueryPool queryPool
,
2695 uint32_t startQuery
,
2696 uint32_t queryCount
);
2698 void VKAPI
vkCmdWriteTimestamp(
2699 VkCmdBuffer cmdBuffer
,
2700 VkTimestampType timestampType
,
2701 VkBuffer destBuffer
,
2702 VkDeviceSize destOffset
);
2704 void VKAPI
vkCmdCopyQueryPoolResults(
2705 VkCmdBuffer cmdBuffer
,
2706 VkQueryPool queryPool
,
2707 uint32_t startQuery
,
2708 uint32_t queryCount
,
2709 VkBuffer destBuffer
,
2710 VkDeviceSize destOffset
,
2711 VkDeviceSize destStride
,
2712 VkQueryResultFlags flags
);
2714 void VKAPI
vkCmdBeginRenderPass(
2715 VkCmdBuffer cmdBuffer
,
2716 const VkRenderPassBegin
* pRenderPassBegin
);
2718 void VKAPI
vkCmdEndRenderPass(
2719 VkCmdBuffer cmdBuffer
,
2720 VkRenderPass renderPass
);