Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / mesa3d / 1b7b58075620764b88014d2414ea7f0484d19ca7 / . / include / vulkan / vulkan.h
blob: a60b83e7d7a832454082a52aea1c270772af1124 [file] [log] [blame]
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]1#ifndef __vulkan_h_
2#define __vulkan_h_ 1
3
4#ifdef __cplusplus
5extern "C" {
6#endif
7
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]8/*
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]9** Copyright (c) 2015 The Khronos Group Inc.
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]10**
11** Permission is hereby granted, free of charge, to any person obtaining a
12** copy of this software and/or associated documentation files (the
13** "Materials"), to deal in the Materials without restriction, including
14** without limitation the rights to use, copy, modify, merge, publish,
15** distribute, sublicense, and/or sell copies of the Materials, and to
16** permit persons to whom the Materials are furnished to do so, subject to
17** the following conditions:
18**
19** The above copyright notice and this permission notice shall be included
20** in all copies or substantial portions of the Materials.
21**
22** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
26** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
27** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
29*/
30
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]31
32#include "vk_platform.h"
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]33
34#define VK_MAKE_VERSION(major, minor, patch) \
35 ((major << 22) | (minor << 12) | patch)
36
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]37// Vulkan API version supported by this file
Jason Ekstrandbeb0e252015-07-01 16:44:10 -0700[diff] [blame]38#define VK_API_VERSION VK_MAKE_VERSION(0, 90, 0)
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]39
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]40#if defined (__cplusplus) && (VK_UINTPTRLEAST64_MAX == UINTPTR_MAX)
41 #define VK_TYPE_SAFE_COMPATIBLE_HANDLES 1
42#endif
43
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;
47
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)
51#else
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;
55#endif
56
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]57
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]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
62#define VK_TRUE 1
63#define VK_FALSE 0
64#define VK_NULL_HANDLE 0
65
66VK_DEFINE_BASE_HANDLE(VkObject)
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]67VK_DEFINE_DISP_SUBCLASS_HANDLE(VkInstance, VkObject)
68VK_DEFINE_DISP_SUBCLASS_HANDLE(VkPhysicalDevice, VkObject)
69VK_DEFINE_DISP_SUBCLASS_HANDLE(VkDevice, VkObject)
70VK_DEFINE_DISP_SUBCLASS_HANDLE(VkQueue, VkObject)
71VK_DEFINE_DISP_SUBCLASS_HANDLE(VkCmdBuffer, VkObject)
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]72VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkNonDispatchable, VkObject)
73VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDeviceMemory, VkNonDispatchable)
74VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBuffer, VkNonDispatchable)
75VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBufferView, VkNonDispatchable)
76VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImage, VkNonDispatchable)
77VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImageView, VkNonDispatchable)
78VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkColorAttachmentView, VkNonDispatchable)
79VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDepthStencilView, VkNonDispatchable)
80VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader, VkNonDispatchable)
81VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline, VkNonDispatchable)
82VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout, VkNonDispatchable)
83VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSampler, VkNonDispatchable)
84VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSet, VkNonDispatchable)
85VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSetLayout, VkNonDispatchable)
86VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorPool, VkNonDispatchable)
87VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicStateObject, VkNonDispatchable)
88VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicVpState, VkDynamicStateObject)
89VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicRsState, VkDynamicStateObject)
90VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicCbState, VkDynamicStateObject)
91VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicDsState, VkDynamicStateObject)
92VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFence, VkNonDispatchable)
93VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSemaphore, VkNonDispatchable)
94VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkEvent, VkNonDispatchable)
95VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkQueryPool, VkNonDispatchable)
96VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFramebuffer, VkNonDispatchable)
97VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable)
98
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]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
106
107// This macro defines the BEGIN_RANGE, END_RANGE, NUM, and MAX_ENUM constants for
108// the enumerations.
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), \
113 VK_MAX_ENUM(Prefix)
114
115// This is a helper macro to define the value of flag bit enum values.
116#define VK_BIT(bit) (1 << (bit))
117
118// ------------------------------------------------------------------------------------------------
119// Enumerations
120
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]121typedef enum VkResult_
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]122{
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]123 // Return codes for successful operation execution (> = 0)
124 VK_SUCCESS = 0x0000000,
125 VK_UNSUPPORTED = 0x0000001,
126 VK_NOT_READY = 0x0000002,
127 VK_TIMEOUT = 0x0000003,
128 VK_EVENT_SET = 0x0000004,
129 VK_EVENT_RESET = 0x0000005,
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]130
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]131 // Error codes (negative values)
132 VK_ERROR_UNKNOWN = -(0x00000001),
133 VK_ERROR_UNAVAILABLE = -(0x00000002),
134 VK_ERROR_INITIALIZATION_FAILED = -(0x00000003),
135 VK_ERROR_OUT_OF_HOST_MEMORY = -(0x00000004),
136 VK_ERROR_OUT_OF_DEVICE_MEMORY = -(0x00000005),
137 VK_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006),
138 VK_ERROR_DEVICE_LOST = -(0x00000007),
139 VK_ERROR_INVALID_POINTER = -(0x00000008),
140 VK_ERROR_INVALID_VALUE = -(0x00000009),
141 VK_ERROR_INVALID_HANDLE = -(0x0000000A),
142 VK_ERROR_INVALID_ORDINAL = -(0x0000000B),
143 VK_ERROR_INVALID_MEMORY_SIZE = -(0x0000000C),
144 VK_ERROR_INVALID_EXTENSION = -(0x0000000D),
145 VK_ERROR_INVALID_FLAGS = -(0x0000000E),
146 VK_ERROR_INVALID_ALIGNMENT = -(0x0000000F),
147 VK_ERROR_INVALID_FORMAT = -(0x00000010),
148 VK_ERROR_INVALID_IMAGE = -(0x00000011),
149 VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -(0x00000012),
150 VK_ERROR_INVALID_QUEUE_TYPE = -(0x00000013),
151 VK_ERROR_INVALID_OBJECT_TYPE = -(0x00000014),
152 VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -(0x00000015),
153 VK_ERROR_BAD_SHADER_CODE = -(0x00000016),
154 VK_ERROR_BAD_PIPELINE_DATA = -(0x00000017),
155 VK_ERROR_TOO_MANY_MEMORY_REFERENCES = -(0x00000018),
156 VK_ERROR_NOT_MAPPABLE = -(0x00000019),
157 VK_ERROR_MEMORY_MAP_FAILED = -(0x0000001A),
158 VK_ERROR_MEMORY_UNMAP_FAILED = -(0x0000001B),
159 VK_ERROR_INCOMPATIBLE_DEVICE = -(0x0000001C),
160 VK_ERROR_INCOMPATIBLE_DRIVER = -(0x0000001D),
161 VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -(0x0000001E),
162 VK_ERROR_BUILDING_COMMAND_BUFFER = -(0x0000001F),
163 VK_ERROR_MEMORY_NOT_BOUND = -(0x00000020),
164 VK_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021),
165 VK_ERROR_NOT_SHAREABLE = -(0x00000022),
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]166
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]167 VK_MAX_ENUM(RESULT)
168} VkResult;
169
170// Structure type enumerant
171typedef enum VkStructureType_
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]172{
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]173 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
174 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
175 VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
176 VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 3,
177 VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 4,
178 VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 5,
179 VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 6,
180 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 7,
181 VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 8,
182 VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 9,
183 VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 10,
184 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 11,
185 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 12,
186 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 13,
187 VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 14,
188 VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 15,
189 VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 16,
190 VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 17,
191 VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 18,
192 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 19,
193 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 20,
194 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 21,
195 VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 22,
196 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 23,
197 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 24,
198 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 25,
199 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 26,
200 VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 27,
201 VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 28,
202 VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 29,
203 VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 30,
204 VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 31,
205 VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 32,
206 VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 33,
207 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 34,
208 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 35,
209 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 36,
210 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
211 VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 38,
212 VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 39,
213 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 40,
214 VK_STRUCTURE_TYPE_LAYER_CREATE_INFO = 41,
215 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 42,
216 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
217 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
218 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 45,
219 VK_STRUCTURE_TYPE_UPDATE_SAMPLERS = 46,
220 VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 47,
221 VK_STRUCTURE_TYPE_UPDATE_IMAGES = 48,
222 VK_STRUCTURE_TYPE_UPDATE_BUFFERS = 49,
223 VK_STRUCTURE_TYPE_UPDATE_AS_COPY = 50,
224 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 51,
225 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 52,
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]226
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]227 VK_ENUM_RANGE(STRUCTURE_TYPE, APPLICATION_INFO, PIPELINE_LAYOUT_CREATE_INFO)
228} VkStructureType;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]229
230typedef enum VkSystemAllocType_
231{
232 VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0x00000000,
233 VK_SYSTEM_ALLOC_TYPE_INTERNAL = 0x00000001,
234 VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 0x00000002,
235 VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 0x00000003,
236 VK_SYSTEM_ALLOC_TYPE_DEBUG = 0x00000004,
237
238 VK_ENUM_RANGE(SYSTEM_ALLOC_TYPE, API_OBJECT, DEBUG)
239} VkSystemAllocType;
240
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]241// Vulkan format definitions
242typedef enum VkFormat_
243{
244 VK_FORMAT_UNDEFINED = 0x00000000,
245 VK_FORMAT_R4G4_UNORM = 0x00000001,
246 VK_FORMAT_R4G4_USCALED = 0x00000002,
247 VK_FORMAT_R4G4B4A4_UNORM = 0x00000003,
248 VK_FORMAT_R4G4B4A4_USCALED = 0x00000004,
249 VK_FORMAT_R5G6B5_UNORM = 0x00000005,
250 VK_FORMAT_R5G6B5_USCALED = 0x00000006,
251 VK_FORMAT_R5G5B5A1_UNORM = 0x00000007,
252 VK_FORMAT_R5G5B5A1_USCALED = 0x00000008,
253 VK_FORMAT_R8_UNORM = 0x00000009,
254 VK_FORMAT_R8_SNORM = 0x0000000A,
255 VK_FORMAT_R8_USCALED = 0x0000000B,
256 VK_FORMAT_R8_SSCALED = 0x0000000C,
257 VK_FORMAT_R8_UINT = 0x0000000D,
258 VK_FORMAT_R8_SINT = 0x0000000E,
259 VK_FORMAT_R8_SRGB = 0x0000000F,
260 VK_FORMAT_R8G8_UNORM = 0x00000010,
261 VK_FORMAT_R8G8_SNORM = 0x00000011,
262 VK_FORMAT_R8G8_USCALED = 0x00000012,
263 VK_FORMAT_R8G8_SSCALED = 0x00000013,
264 VK_FORMAT_R8G8_UINT = 0x00000014,
265 VK_FORMAT_R8G8_SINT = 0x00000015,
266 VK_FORMAT_R8G8_SRGB = 0x00000016,
267 VK_FORMAT_R8G8B8_UNORM = 0x00000017,
268 VK_FORMAT_R8G8B8_SNORM = 0x00000018,
269 VK_FORMAT_R8G8B8_USCALED = 0x00000019,
270 VK_FORMAT_R8G8B8_SSCALED = 0x0000001A,
271 VK_FORMAT_R8G8B8_UINT = 0x0000001B,
272 VK_FORMAT_R8G8B8_SINT = 0x0000001C,
273 VK_FORMAT_R8G8B8_SRGB = 0x0000001D,
274 VK_FORMAT_R8G8B8A8_UNORM = 0x0000001E,
275 VK_FORMAT_R8G8B8A8_SNORM = 0x0000001F,
276 VK_FORMAT_R8G8B8A8_USCALED = 0x00000020,
277 VK_FORMAT_R8G8B8A8_SSCALED = 0x00000021,
278 VK_FORMAT_R8G8B8A8_UINT = 0x00000022,
279 VK_FORMAT_R8G8B8A8_SINT = 0x00000023,
280 VK_FORMAT_R8G8B8A8_SRGB = 0x00000024,
281 VK_FORMAT_R10G10B10A2_UNORM = 0x00000025,
282 VK_FORMAT_R10G10B10A2_SNORM = 0x00000026,
283 VK_FORMAT_R10G10B10A2_USCALED = 0x00000027,
284 VK_FORMAT_R10G10B10A2_SSCALED = 0x00000028,
285 VK_FORMAT_R10G10B10A2_UINT = 0x00000029,
286 VK_FORMAT_R10G10B10A2_SINT = 0x0000002A,
287 VK_FORMAT_R16_UNORM = 0x0000002B,
288 VK_FORMAT_R16_SNORM = 0x0000002C,
289 VK_FORMAT_R16_USCALED = 0x0000002D,
290 VK_FORMAT_R16_SSCALED = 0x0000002E,
291 VK_FORMAT_R16_UINT = 0x0000002F,
292 VK_FORMAT_R16_SINT = 0x00000030,
293 VK_FORMAT_R16_SFLOAT = 0x00000031,
294 VK_FORMAT_R16G16_UNORM = 0x00000032,
295 VK_FORMAT_R16G16_SNORM = 0x00000033,
296 VK_FORMAT_R16G16_USCALED = 0x00000034,
297 VK_FORMAT_R16G16_SSCALED = 0x00000035,
298 VK_FORMAT_R16G16_UINT = 0x00000036,
299 VK_FORMAT_R16G16_SINT = 0x00000037,
300 VK_FORMAT_R16G16_SFLOAT = 0x00000038,
301 VK_FORMAT_R16G16B16_UNORM = 0x00000039,
302 VK_FORMAT_R16G16B16_SNORM = 0x0000003A,
303 VK_FORMAT_R16G16B16_USCALED = 0x0000003B,
304 VK_FORMAT_R16G16B16_SSCALED = 0x0000003C,
305 VK_FORMAT_R16G16B16_UINT = 0x0000003D,
306 VK_FORMAT_R16G16B16_SINT = 0x0000003E,
307 VK_FORMAT_R16G16B16_SFLOAT = 0x0000003F,
308 VK_FORMAT_R16G16B16A16_UNORM = 0x00000040,
309 VK_FORMAT_R16G16B16A16_SNORM = 0x00000041,
310 VK_FORMAT_R16G16B16A16_USCALED = 0x00000042,
311 VK_FORMAT_R16G16B16A16_SSCALED = 0x00000043,
312 VK_FORMAT_R16G16B16A16_UINT = 0x00000044,
313 VK_FORMAT_R16G16B16A16_SINT = 0x00000045,
314 VK_FORMAT_R16G16B16A16_SFLOAT = 0x00000046,
315 VK_FORMAT_R32_UINT = 0x00000047,
316 VK_FORMAT_R32_SINT = 0x00000048,
317 VK_FORMAT_R32_SFLOAT = 0x00000049,
318 VK_FORMAT_R32G32_UINT = 0x0000004A,
319 VK_FORMAT_R32G32_SINT = 0x0000004B,
320 VK_FORMAT_R32G32_SFLOAT = 0x0000004C,
321 VK_FORMAT_R32G32B32_UINT = 0x0000004D,
322 VK_FORMAT_R32G32B32_SINT = 0x0000004E,
323 VK_FORMAT_R32G32B32_SFLOAT = 0x0000004F,
324 VK_FORMAT_R32G32B32A32_UINT = 0x00000050,
325 VK_FORMAT_R32G32B32A32_SINT = 0x00000051,
326 VK_FORMAT_R32G32B32A32_SFLOAT = 0x00000052,
327 VK_FORMAT_R64_SFLOAT = 0x00000053,
328 VK_FORMAT_R64G64_SFLOAT = 0x00000054,
329 VK_FORMAT_R64G64B64_SFLOAT = 0x00000055,
330 VK_FORMAT_R64G64B64A64_SFLOAT = 0x00000056,
331 VK_FORMAT_R11G11B10_UFLOAT = 0x00000057,
332 VK_FORMAT_R9G9B9E5_UFLOAT = 0x00000058,
333 VK_FORMAT_D16_UNORM = 0x00000059,
334 VK_FORMAT_D24_UNORM = 0x0000005A,
335 VK_FORMAT_D32_SFLOAT = 0x0000005B,
336 VK_FORMAT_S8_UINT = 0x0000005C,
337 VK_FORMAT_D16_UNORM_S8_UINT = 0x0000005D,
338 VK_FORMAT_D24_UNORM_S8_UINT = 0x0000005E,
339 VK_FORMAT_D32_SFLOAT_S8_UINT = 0x0000005F,
340 VK_FORMAT_BC1_RGB_UNORM = 0x00000060,
341 VK_FORMAT_BC1_RGB_SRGB = 0x00000061,
342 VK_FORMAT_BC1_RGBA_UNORM = 0x00000062,
343 VK_FORMAT_BC1_RGBA_SRGB = 0x00000063,
344 VK_FORMAT_BC2_UNORM = 0x00000064,
345 VK_FORMAT_BC2_SRGB = 0x00000065,
346 VK_FORMAT_BC3_UNORM = 0x00000066,
347 VK_FORMAT_BC3_SRGB = 0x00000067,
348 VK_FORMAT_BC4_UNORM = 0x00000068,
349 VK_FORMAT_BC4_SNORM = 0x00000069,
350 VK_FORMAT_BC5_UNORM = 0x0000006A,
351 VK_FORMAT_BC5_SNORM = 0x0000006B,
352 VK_FORMAT_BC6H_UFLOAT = 0x0000006C,
353 VK_FORMAT_BC6H_SFLOAT = 0x0000006D,
354 VK_FORMAT_BC7_UNORM = 0x0000006E,
355 VK_FORMAT_BC7_SRGB = 0x0000006F,
356 VK_FORMAT_ETC2_R8G8B8_UNORM = 0x00000070,
357 VK_FORMAT_ETC2_R8G8B8_SRGB = 0x00000071,
358 VK_FORMAT_ETC2_R8G8B8A1_UNORM = 0x00000072,
359 VK_FORMAT_ETC2_R8G8B8A1_SRGB = 0x00000073,
360 VK_FORMAT_ETC2_R8G8B8A8_UNORM = 0x00000074,
361 VK_FORMAT_ETC2_R8G8B8A8_SRGB = 0x00000075,
362 VK_FORMAT_EAC_R11_UNORM = 0x00000076,
363 VK_FORMAT_EAC_R11_SNORM = 0x00000077,
364 VK_FORMAT_EAC_R11G11_UNORM = 0x00000078,
365 VK_FORMAT_EAC_R11G11_SNORM = 0x00000079,
366 VK_FORMAT_ASTC_4x4_UNORM = 0x0000007A,
367 VK_FORMAT_ASTC_4x4_SRGB = 0x0000007B,
368 VK_FORMAT_ASTC_5x4_UNORM = 0x0000007C,
369 VK_FORMAT_ASTC_5x4_SRGB = 0x0000007D,
370 VK_FORMAT_ASTC_5x5_UNORM = 0x0000007E,
371 VK_FORMAT_ASTC_5x5_SRGB = 0x0000007F,
372 VK_FORMAT_ASTC_6x5_UNORM = 0x00000080,
373 VK_FORMAT_ASTC_6x5_SRGB = 0x00000081,
374 VK_FORMAT_ASTC_6x6_UNORM = 0x00000082,
375 VK_FORMAT_ASTC_6x6_SRGB = 0x00000083,
376 VK_FORMAT_ASTC_8x5_UNORM = 0x00000084,
377 VK_FORMAT_ASTC_8x5_SRGB = 0x00000085,
378 VK_FORMAT_ASTC_8x6_UNORM = 0x00000086,
379 VK_FORMAT_ASTC_8x6_SRGB = 0x00000087,
380 VK_FORMAT_ASTC_8x8_UNORM = 0x00000088,
381 VK_FORMAT_ASTC_8x8_SRGB = 0x00000089,
382 VK_FORMAT_ASTC_10x5_UNORM = 0x0000008A,
383 VK_FORMAT_ASTC_10x5_SRGB = 0x0000008B,
384 VK_FORMAT_ASTC_10x6_UNORM = 0x0000008C,
385 VK_FORMAT_ASTC_10x6_SRGB = 0x0000008D,
386 VK_FORMAT_ASTC_10x8_UNORM = 0x0000008E,
387 VK_FORMAT_ASTC_10x8_SRGB = 0x0000008F,
388 VK_FORMAT_ASTC_10x10_UNORM = 0x00000090,
389 VK_FORMAT_ASTC_10x10_SRGB = 0x00000091,
390 VK_FORMAT_ASTC_12x10_UNORM = 0x00000092,
391 VK_FORMAT_ASTC_12x10_SRGB = 0x00000093,
392 VK_FORMAT_ASTC_12x12_UNORM = 0x00000094,
393 VK_FORMAT_ASTC_12x12_SRGB = 0x00000095,
394 VK_FORMAT_B4G4R4A4_UNORM = 0x00000096,
395 VK_FORMAT_B5G5R5A1_UNORM = 0x00000097,
396 VK_FORMAT_B5G6R5_UNORM = 0x00000098,
397 VK_FORMAT_B5G6R5_USCALED = 0x00000099,
398 VK_FORMAT_B8G8R8_UNORM = 0x0000009A,
399 VK_FORMAT_B8G8R8_SNORM = 0x0000009B,
400 VK_FORMAT_B8G8R8_USCALED = 0x0000009C,
401 VK_FORMAT_B8G8R8_SSCALED = 0x0000009D,
402 VK_FORMAT_B8G8R8_UINT = 0x0000009E,
403 VK_FORMAT_B8G8R8_SINT = 0x0000009F,
404 VK_FORMAT_B8G8R8_SRGB = 0x000000A0,
405 VK_FORMAT_B8G8R8A8_UNORM = 0x000000A1,
406 VK_FORMAT_B8G8R8A8_SNORM = 0x000000A2,
407 VK_FORMAT_B8G8R8A8_USCALED = 0x000000A3,
408 VK_FORMAT_B8G8R8A8_SSCALED = 0x000000A4,
409 VK_FORMAT_B8G8R8A8_UINT = 0x000000A5,
410 VK_FORMAT_B8G8R8A8_SINT = 0x000000A6,
411 VK_FORMAT_B8G8R8A8_SRGB = 0x000000A7,
412 VK_FORMAT_B10G10R10A2_UNORM = 0x000000A8,
413 VK_FORMAT_B10G10R10A2_SNORM = 0x000000A9,
414 VK_FORMAT_B10G10R10A2_USCALED = 0x000000AA,
415 VK_FORMAT_B10G10R10A2_SSCALED = 0x000000AB,
416 VK_FORMAT_B10G10R10A2_UINT = 0x000000AC,
417 VK_FORMAT_B10G10R10A2_SINT = 0x000000AD,
418
419 VK_ENUM_RANGE(FORMAT, UNDEFINED, B10G10R10A2_SINT)
420} VkFormat;
421
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]422typedef enum VkPhysicalDeviceType_
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]423{
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]424 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0x00000000,
425 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 0x00000001,
426 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 0x00000002,
427 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 0x00000003,
428 VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004,
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]429
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]430 VK_ENUM_RANGE(PHYSICAL_DEVICE_TYPE, OTHER, CPU)
431} VkPhysicalDeviceType;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]432
433// Object type enumerant
434typedef enum VkObjectType_
435{
436 VK_OBJECT_TYPE_INSTANCE = 0,
437 VK_OBJECT_TYPE_PHYSICAL_DEVICE = 1,
438 VK_OBJECT_TYPE_DEVICE = 2,
439 VK_OBJECT_TYPE_QUEUE = 3,
440 VK_OBJECT_TYPE_COMMAND_BUFFER = 4,
441 VK_OBJECT_TYPE_DEVICE_MEMORY = 5,
442 VK_OBJECT_TYPE_BUFFER = 6,
443 VK_OBJECT_TYPE_BUFFER_VIEW = 7,
444 VK_OBJECT_TYPE_IMAGE = 8,
445 VK_OBJECT_TYPE_IMAGE_VIEW = 9,
446 VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW = 10,
447 VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW = 11,
448 VK_OBJECT_TYPE_SHADER = 12,
449 VK_OBJECT_TYPE_PIPELINE = 13,
450 VK_OBJECT_TYPE_PIPELINE_LAYOUT = 14,
451 VK_OBJECT_TYPE_SAMPLER = 15,
452 VK_OBJECT_TYPE_DESCRIPTOR_SET = 16,
453 VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 17,
454 VK_OBJECT_TYPE_DESCRIPTOR_POOL = 18,
455 VK_OBJECT_TYPE_DYNAMIC_VP_STATE = 19,
456 VK_OBJECT_TYPE_DYNAMIC_RS_STATE = 20,
457 VK_OBJECT_TYPE_DYNAMIC_CB_STATE = 21,
458 VK_OBJECT_TYPE_DYNAMIC_DS_STATE = 22,
459 VK_OBJECT_TYPE_FENCE = 23,
460 VK_OBJECT_TYPE_SEMAPHORE = 24,
461 VK_OBJECT_TYPE_EVENT = 25,
462 VK_OBJECT_TYPE_QUERY_POOL = 26,
463 VK_OBJECT_TYPE_FRAMEBUFFER = 27,
464 VK_OBJECT_TYPE_RENDER_PASS = 28,
465
466 // Valid ranges for core Vulkan:
467 VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE,
468 VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_RENDER_PASS,
469 VK_NUM_OBJECT_TYPE = (VK_OBJECT_TYPE_END_RANGE - VK_OBJECT_TYPE_BEGIN_RANGE + 1),
470 VK_MAX_ENUM(VkObjectType)
471} VkObjectType;
472
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]473typedef enum VkImageAspect_
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]474{
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]475 VK_IMAGE_ASPECT_COLOR = 0x00000000,
476 VK_IMAGE_ASPECT_DEPTH = 0x00000001,
477 VK_IMAGE_ASPECT_STENCIL = 0x00000002,
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]478
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]479 VK_ENUM_RANGE(IMAGE_ASPECT, COLOR, STENCIL)
480} VkImageAspect;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]481
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]482typedef enum VkQueryType_
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]483{
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]484 VK_QUERY_TYPE_OCCLUSION = 0x00000000,
485 VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, // Optional
486
487 VK_ENUM_RANGE(QUERY_TYPE, OCCLUSION, PIPELINE_STATISTICS)
488} VkQueryType;
489
490typedef enum VkBufferViewType_
491{
492 VK_BUFFER_VIEW_TYPE_RAW = 0x00000000, // Raw buffer without special structure (UBO, SSBO)
493 VK_BUFFER_VIEW_TYPE_FORMATTED = 0x00000001, // Buffer with format (TBO, IBO)
494
495 VK_ENUM_RANGE(BUFFER_VIEW_TYPE, RAW, FORMATTED)
496} VkBufferViewType;
497
498typedef enum VkImageType_
499{
500 VK_IMAGE_TYPE_1D = 0x00000000,
501 VK_IMAGE_TYPE_2D = 0x00000001,
502 VK_IMAGE_TYPE_3D = 0x00000002,
503
504 VK_ENUM_RANGE(IMAGE_TYPE, 1D, 3D)
505} VkImageType;
506
507typedef enum VkImageTiling_
508{
509 VK_IMAGE_TILING_LINEAR = 0x00000000,
510 VK_IMAGE_TILING_OPTIMAL = 0x00000001,
511
512 VK_ENUM_RANGE(IMAGE_TILING, LINEAR, OPTIMAL)
513} VkImageTiling;
514
515typedef enum VkImageViewType_
516{
517 VK_IMAGE_VIEW_TYPE_1D = 0x00000000,
518 VK_IMAGE_VIEW_TYPE_2D = 0x00000001,
519 VK_IMAGE_VIEW_TYPE_3D = 0x00000002,
520 VK_IMAGE_VIEW_TYPE_CUBE = 0x00000003,
521
522 VK_ENUM_RANGE(IMAGE_VIEW_TYPE, 1D, CUBE)
523} VkImageViewType;
524
525typedef enum VkChannelSwizzle_
526{
527 VK_CHANNEL_SWIZZLE_ZERO = 0x00000000,
528 VK_CHANNEL_SWIZZLE_ONE = 0x00000001,
529 VK_CHANNEL_SWIZZLE_R = 0x00000002,
530 VK_CHANNEL_SWIZZLE_G = 0x00000003,
531 VK_CHANNEL_SWIZZLE_B = 0x00000004,
532 VK_CHANNEL_SWIZZLE_A = 0x00000005,
533
534 VK_ENUM_RANGE(CHANNEL_SWIZZLE, ZERO, A)
535} VkChannelSwizzle;
536
537// Shader stage enumerant
538typedef enum VkShaderStage_
539{
540 VK_SHADER_STAGE_VERTEX = 0,
541 VK_SHADER_STAGE_TESS_CONTROL = 1,
542 VK_SHADER_STAGE_TESS_EVALUATION = 2,
543 VK_SHADER_STAGE_GEOMETRY = 3,
544 VK_SHADER_STAGE_FRAGMENT = 4,
545 VK_SHADER_STAGE_COMPUTE = 5,
546
547 VK_ENUM_RANGE(SHADER_STAGE, VERTEX, COMPUTE)
548} VkShaderStage;
549
550typedef enum VkVertexInputStepRate_
551{
552 VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0,
553 VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1,
554 VK_VERTEX_INPUT_STEP_RATE_DRAW = 0x2, //Optional
555
556 VK_ENUM_RANGE(VERTEX_INPUT_STEP_RATE, VERTEX, DRAW)
557} VkVertexInputStepRate;
558
559typedef enum VkPrimitiveTopology_
560{
561 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0x00000000,
562 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 0x00000001,
563 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 0x00000002,
564 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003,
565 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004,
566 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005,
567 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 0x00000006,
568 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007,
569 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008,
570 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009,
571 VK_PRIMITIVE_TOPOLOGY_PATCH = 0x0000000a,
572
573 VK_ENUM_RANGE(PRIMITIVE_TOPOLOGY, POINT_LIST, PATCH)
574} VkPrimitiveTopology;
575
576typedef enum VkFillMode_
577{
578 VK_FILL_MODE_POINTS = 0x00000000,
579 VK_FILL_MODE_WIREFRAME = 0x00000001,
580 VK_FILL_MODE_SOLID = 0x00000002,
581
582 VK_ENUM_RANGE(FILL_MODE, POINTS, SOLID)
583} VkFillMode;
584
585typedef enum VkCullMode_
586{
587 VK_CULL_MODE_NONE = 0x00000000,
588 VK_CULL_MODE_FRONT = 0x00000001,
589 VK_CULL_MODE_BACK = 0x00000002,
590 VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
591
592 VK_ENUM_RANGE(CULL_MODE, NONE, FRONT_AND_BACK)
593} VkCullMode;
594
595typedef enum VkFrontFace_
596{
597 VK_FRONT_FACE_CCW = 0x00000000,
598 VK_FRONT_FACE_CW = 0x00000001,
599
600 VK_ENUM_RANGE(FRONT_FACE, CCW, CW)
601} VkFrontFace;
602
603typedef enum VkCompareOp_
604{
605 VK_COMPARE_OP_NEVER = 0x00000000,
606 VK_COMPARE_OP_LESS = 0x00000001,
607 VK_COMPARE_OP_EQUAL = 0x00000002,
608 VK_COMPARE_OP_LESS_EQUAL = 0x00000003,
609 VK_COMPARE_OP_GREATER = 0x00000004,
610 VK_COMPARE_OP_NOT_EQUAL = 0x00000005,
611 VK_COMPARE_OP_GREATER_EQUAL = 0x00000006,
612 VK_COMPARE_OP_ALWAYS = 0x00000007,
613
614 VK_ENUM_RANGE(COMPARE_OP, NEVER, ALWAYS)
615} VkCompareOp;
616
617typedef enum VkStencilOp_
618{
619 VK_STENCIL_OP_KEEP = 0x00000000,
620 VK_STENCIL_OP_ZERO = 0x00000001,
621 VK_STENCIL_OP_REPLACE = 0x00000002,
622 VK_STENCIL_OP_INC_CLAMP = 0x00000003,
623 VK_STENCIL_OP_DEC_CLAMP = 0x00000004,
624 VK_STENCIL_OP_INVERT = 0x00000005,
625 VK_STENCIL_OP_INC_WRAP = 0x00000006,
626 VK_STENCIL_OP_DEC_WRAP = 0x00000007,
627
628 VK_ENUM_RANGE(STENCIL_OP, KEEP, DEC_WRAP)
629} VkStencilOp;
630
631typedef enum VkLogicOp_
632{
633 VK_LOGIC_OP_COPY = 0x00000000,
634 VK_LOGIC_OP_CLEAR = 0x00000001,
635 VK_LOGIC_OP_AND = 0x00000002,
636 VK_LOGIC_OP_AND_REVERSE = 0x00000003,
637 VK_LOGIC_OP_AND_INVERTED = 0x00000004,
638 VK_LOGIC_OP_NOOP = 0x00000005,
639 VK_LOGIC_OP_XOR = 0x00000006,
640 VK_LOGIC_OP_OR = 0x00000007,
641 VK_LOGIC_OP_NOR = 0x00000008,
642 VK_LOGIC_OP_EQUIV = 0x00000009,
643 VK_LOGIC_OP_INVERT = 0x0000000a,
644 VK_LOGIC_OP_OR_REVERSE = 0x0000000b,
645 VK_LOGIC_OP_COPY_INVERTED = 0x0000000c,
646 VK_LOGIC_OP_OR_INVERTED = 0x0000000d,
647 VK_LOGIC_OP_NAND = 0x0000000e,
648 VK_LOGIC_OP_SET = 0x0000000f,
649
650 VK_ENUM_RANGE(LOGIC_OP, COPY, SET)
651} VkLogicOp;
652
653typedef enum VkBlend_
654{
655 VK_BLEND_ZERO = 0x00000000,
656 VK_BLEND_ONE = 0x00000001,
657 VK_BLEND_SRC_COLOR = 0x00000002,
658 VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
659 VK_BLEND_DEST_COLOR = 0x00000004,
660 VK_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005,
661 VK_BLEND_SRC_ALPHA = 0x00000006,
662 VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007,
663 VK_BLEND_DEST_ALPHA = 0x00000008,
664 VK_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009,
665 VK_BLEND_CONSTANT_COLOR = 0x0000000a,
666 VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
667 VK_BLEND_CONSTANT_ALPHA = 0x0000000c,
668 VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
669 VK_BLEND_SRC_ALPHA_SATURATE = 0x0000000e,
670 VK_BLEND_SRC1_COLOR = 0x0000000f,
671 VK_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010,
672 VK_BLEND_SRC1_ALPHA = 0x00000011,
673 VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012,
674
675 VK_ENUM_RANGE(BLEND, ZERO, ONE_MINUS_SRC1_ALPHA)
676} VkBlend;
677
678typedef enum VkBlendOp_
679{
680 VK_BLEND_OP_ADD = 0x00000000,
681 VK_BLEND_OP_SUBTRACT = 0x00000001,
682 VK_BLEND_OP_REVERSE_SUBTRACT = 0x00000002,
683 VK_BLEND_OP_MIN = 0x00000003,
684 VK_BLEND_OP_MAX = 0x00000004,
685
686 VK_ENUM_RANGE(BLEND_OP, ADD, MAX)
687} VkBlendOp;
688
689typedef enum VkTexFilter_
690{
691 VK_TEX_FILTER_NEAREST = 0x00000000,
692 VK_TEX_FILTER_LINEAR = 0x00000001,
693
694 VK_ENUM_RANGE(TEX_FILTER, NEAREST, LINEAR)
695} VkTexFilter;
696
697typedef enum VkTexMipmapMode_
698{
699 VK_TEX_MIPMAP_MODE_BASE = 0x00000000, // Always choose base level
700 VK_TEX_MIPMAP_MODE_NEAREST = 0x00000001, // Choose nearest mip level
701 VK_TEX_MIPMAP_MODE_LINEAR = 0x00000002, // Linear filter between mip levels
702
703 VK_ENUM_RANGE(TEX_MIPMAP_MODE, BASE, LINEAR)
704} VkTexMipmapMode;
705
706typedef enum VkTexAddress_
707{
708 VK_TEX_ADDRESS_WRAP = 0x00000000,
709 VK_TEX_ADDRESS_MIRROR = 0x00000001,
710 VK_TEX_ADDRESS_CLAMP = 0x00000002,
711 VK_TEX_ADDRESS_MIRROR_ONCE = 0x00000003,
712 VK_TEX_ADDRESS_CLAMP_BORDER = 0x00000004,
713
714 VK_ENUM_RANGE(TEX_ADDRESS, WRAP, CLAMP_BORDER)
715} VkTexAddress;
716
717typedef enum VkBorderColor_
718{
719 VK_BORDER_COLOR_OPAQUE_WHITE = 0x00000000,
720 VK_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001,
721 VK_BORDER_COLOR_OPAQUE_BLACK = 0x00000002,
722
723 VK_ENUM_RANGE(BORDER_COLOR, OPAQUE_WHITE, OPAQUE_BLACK)
724} VkBorderColor;
725
726typedef enum VkDescriptorType_
727{
728 VK_DESCRIPTOR_TYPE_SAMPLER = 0x00000000,
729 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 0x00000001,
730 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 0x00000002,
731 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 0x00000003,
732 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 0x00000004,
733 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 0x00000005,
734 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006,
735 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 0x00000007,
736 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000008,
737 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 0x00000009,
738
739 VK_ENUM_RANGE(DESCRIPTOR_TYPE, SAMPLER, STORAGE_BUFFER_DYNAMIC)
740} VkDescriptorType;
741
742typedef enum VkDescriptorPoolUsage_
743{
744 VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000,
745 VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001,
746
747 VK_ENUM_RANGE(DESCRIPTOR_POOL_USAGE, ONE_SHOT, DYNAMIC)
748} VkDescriptorPoolUsage;
749
750typedef enum VkDescriptorUpdateMode_
751{
752 VK_DESCRIPTOR_UPDATE_MODE_COPY = 0x00000000,
753 VK_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001,
754
755 VK_ENUM_RANGE(DESCRIPTOR_UPDATE_MODE, COPY, FASTEST)
756} VkDescriptorUpdateMode;
757
758typedef enum VkDescriptorSetUsage_
759{
760 VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000,
761 VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001,
762
763 VK_ENUM_RANGE(DESCRIPTOR_SET_USAGE, ONE_SHOT, STATIC)
764} VkDescriptorSetUsage;
765
766typedef enum VkImageLayout_
767{
768 VK_IMAGE_LAYOUT_UNDEFINED = 0x00000000, // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
769 VK_IMAGE_LAYOUT_GENERAL = 0x00000001, // General layout when image can be used for any kind of access
770 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000002, // Optimal layout when image is only used for color attachment read/write
771 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, // Optimal layout when image is only used for depth/stencil attachment read/write
772 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, // Optimal layout when image is used for read only depth/stencil attachment and shader access
773 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, // Optimal layout when image is used for read only shader access
774 VK_IMAGE_LAYOUT_CLEAR_OPTIMAL = 0x00000006, // Optimal layout when image is used only for clear operations
775 VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000007, // Optimal layout when image is used only as source of transfer operations
776 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000008, // Optimal layout when image is used only as destination of transfer operations
777
778 VK_ENUM_RANGE(IMAGE_LAYOUT, UNDEFINED, TRANSFER_DESTINATION_OPTIMAL)
779} VkImageLayout;
780
781typedef enum VkAttachmentLoadOp_
782{
783 VK_ATTACHMENT_LOAD_OP_LOAD = 0x00000000,
784 VK_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001,
785 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002,
786
787 VK_ENUM_RANGE(ATTACHMENT_LOAD_OP, LOAD, DONT_CARE)
788} VkAttachmentLoadOp;
789
790typedef enum VkAttachmentStoreOp_
791{
792 VK_ATTACHMENT_STORE_OP_STORE = 0x00000000,
793 VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001,
794 VK_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000002,
795
796 VK_ENUM_RANGE(ATTACHMENT_STORE_OP, STORE, DONT_CARE)
797} VkAttachmentStoreOp;
798
799typedef enum VkPipelineBindPoint_
800{
801 VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000,
802 VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001,
803
804 VK_ENUM_RANGE(PIPELINE_BIND_POINT, COMPUTE, GRAPHICS)
805} VkPipelineBindPoint;
806
807typedef enum VkStateBindPoint_
808{
809 VK_STATE_BIND_POINT_VIEWPORT = 0x00000000,
810 VK_STATE_BIND_POINT_RASTER = 0x00000001,
811 VK_STATE_BIND_POINT_COLOR_BLEND = 0x00000002,
812 VK_STATE_BIND_POINT_DEPTH_STENCIL = 0x00000003,
813
814 VK_ENUM_RANGE(STATE_BIND_POINT, VIEWPORT, DEPTH_STENCIL)
815} VkStateBindPoint;
816
817typedef enum VkIndexType_
818{
819 VK_INDEX_TYPE_UINT8 = 0x00000000,
820 VK_INDEX_TYPE_UINT16 = 0x00000001,
821 VK_INDEX_TYPE_UINT32 = 0x00000002,
822
823 VK_ENUM_RANGE(INDEX_TYPE, UINT8, UINT32)
824} VkIndexType;
825
826typedef enum VkPipeEvent_
827{
828 VK_PIPE_EVENT_TOP_OF_PIPE = 0x00000001, // Set event before the device starts processing subsequent command
829 VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002, // Set event when all pending vertex processing is complete
830 VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE = 0x00000003, // Set event when all pending fragment shader executions are complete, within each fragment location
831 VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE = 0x00000004, // Set event when all pending fragment shader executions are complete
832 VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE = 0x00000005, // Set event when all pending graphics operations are complete
833 VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE = 0x00000006, // Set event when all pending compute operations are complete
834 VK_PIPE_EVENT_TRANSFER_COMPLETE = 0x00000007, // Set event when all pending transfer operations are complete
835 VK_PIPE_EVENT_COMMANDS_COMPLETE = 0x00000008, // Set event when all pending work is complete
836
837 VK_ENUM_RANGE(PIPE_EVENT, TOP_OF_PIPE, COMMANDS_COMPLETE)
838} VkPipeEvent;
839
840typedef enum VkWaitEvent_
841{
842 VK_WAIT_EVENT_TOP_OF_PIPE = 0x00000001, // Wait event before the device starts processing subsequent commands
843 VK_WAIT_EVENT_BEFORE_RASTERIZATION = 0x00000002, // Wait event before rasterizing subsequent primitives
844
845 VK_ENUM_RANGE(WAIT_EVENT, TOP_OF_PIPE, BEFORE_RASTERIZATION)
846} VkWaitEvent;
847
848typedef enum VkTimestampType_
849{
850 VK_TIMESTAMP_TYPE_TOP = 0x00000000,
851 VK_TIMESTAMP_TYPE_BOTTOM = 0x00000001,
852
853 VK_ENUM_RANGE(TIMESTAMP_TYPE, TOP, BOTTOM)
854} VkTimestampType;
855
856// Format capability flags
857typedef VkFlags VkFormatFeatureFlags;
858typedef enum VkFormatFeatureFlagBits_
859{
860 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = VK_BIT(0), // Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
861 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = VK_BIT(1), // Format can be used for storage images (STORAGE_IMAGE descriptor type)
862 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = VK_BIT(2), // Format supports atomic operations in case it's used for storage images
863 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(3), // Format can be used for uniform texel buffers (TBOs)
864 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(4), // Format can be used for storage texel buffers (IBOs)
865 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = VK_BIT(5), // Format supports atomic operations in case it's used for storage texel buffers
866 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = VK_BIT(6), // Format can be used for vertex buffers (VBOs)
867 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = VK_BIT(7), // Format can be used for color attachment images
868 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = VK_BIT(8), // Format supports blending in case it's used for color attachment images
869 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(9), // Format can be used for depth/stencil attachment images
870 VK_FORMAT_FEATURE_CONVERSION_BIT = VK_BIT(10), // Format can be used as the source or destination of format converting blits
871} VkFormatFeatureFlagBits;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]872
873// Queue capabilities
874typedef VkFlags VkQueueFlags;
875typedef enum VkQueueFlagBits_
876{
877 VK_QUEUE_GRAPHICS_BIT = VK_BIT(0), // Queue supports graphics operations
878 VK_QUEUE_COMPUTE_BIT = VK_BIT(1), // Queue supports compute operations
879 VK_QUEUE_DMA_BIT = VK_BIT(2), // Queue supports DMA operations
880 VK_QUEUE_MEMMGR_BIT = VK_BIT(3), // Queue supports memory management operations
881 VK_QUEUE_EXTENDED_BIT = VK_BIT(30), // Extended queue
882} VkQueueFlagBits;
883
884// Memory properties passed into vkAllocMemory().
885typedef VkFlags VkMemoryPropertyFlags;
886typedef enum VkMemoryPropertyFlagBits_
887{
888 VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, // If otherwise stated, then allocate memory on device
889 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = VK_BIT(0), // Memory should be mappable by host
890 VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT = VK_BIT(1), // Memory should be coherent between host and device accesses
891 VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = VK_BIT(2), // Memory should not be cached by the host
892 VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = VK_BIT(3), // Memory should support host write combining
893 VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL = VK_BIT(4), // If set, prefer host access
894 VK_MEMORY_PROPERTY_SHAREABLE_BIT = VK_BIT(5),
895} VkMemoryPropertyFlagBits;
896
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]897// Device creation flags
898typedef VkFlags VkDeviceCreateFlags;
899typedef enum VkDeviceCreateFlagBits_
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]900{
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]901 VK_DEVICE_CREATE_VALIDATION_BIT = VK_BIT(0),
902 VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT = VK_BIT(1),
903} VkDeviceCreateFlagBits;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]904
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]905// Memory mapping flags
906typedef VkFlags VkMemoryMapFlags;
907
908// Fence creation flags
909typedef VkFlags VkFenceCreateFlags;
910typedef enum VkFenceCreateFlagBits_
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]911{
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]912 VK_FENCE_CREATE_SIGNALED_BIT = VK_BIT(0),
913} VkFenceCreateFlagBits;
914
915// Semaphore creation flags
916typedef VkFlags VkSemaphoreCreateFlags;
917typedef enum VkSemaphoreCreateFlagBits_
918{
919 VK_SEMAPHORE_CREATE_SHAREABLE_BIT = VK_BIT(0),
920} VkSemaphoreCreateFlagBits;
921
922// Event creation flags
923typedef VkFlags VkEventCreateFlags;
924
925// Pipeline statistics flags
926typedef VkFlags VkQueryPipelineStatisticFlags;
927typedef enum VkQueryPipelineStatisticFlagBits_ {
928 VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = VK_BIT(0), // Optional
929 VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = VK_BIT(1), // Optional
930 VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = VK_BIT(2), // Optional
931 VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = VK_BIT(3), // Optional
932 VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = VK_BIT(4), // Optional
933 VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = VK_BIT(5), // Optional
934 VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = VK_BIT(6), // Optional
935 VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = VK_BIT(7), // Optional
936 VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = VK_BIT(8), // Optional
937 VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = VK_BIT(9), // Optional
938 VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = VK_BIT(10), // Optional
939} VkQueryPipelineStatisticFlagBits;
940
941// Query result flags
942typedef VkFlags VkQueryResultFlags;
943typedef enum VkQueryResultFlagBits_
944{
945 VK_QUERY_RESULT_32_BIT = 0, // Results of the queries are written to the destination buffer as 32-bit values
946 VK_QUERY_RESULT_64_BIT = VK_BIT(0), // Results of the queries are written to the destination buffer as 64-bit values
947 VK_QUERY_RESULT_NO_WAIT_BIT = 0, // Results of the queries aren't waited on before proceeding with the result copy
948 VK_QUERY_RESULT_WAIT_BIT = VK_BIT(1), // Results of the queries are waited on before proceeding with the result copy
949 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = VK_BIT(2), // Besides the results of the query, the availability of the results is also written
950 VK_QUERY_RESULT_PARTIAL_BIT = VK_BIT(3), // Copy the partial results of the query even if the final results aren't available
951} VkQueryResultFlagBits;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]952
953// Buffer usage flags
954typedef VkFlags VkBufferUsageFlags;
955typedef enum VkBufferUsageFlagBits_
956{
957 VK_BUFFER_USAGE_GENERAL = 0, // No special usage
958 VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0), // Can be used as a source of transfer operations
959 VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1), // Can be used as a destination of transfer operations
960 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(2), // Can be used as TBO
961 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(3), // Can be used as IBO
962 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = VK_BIT(4), // Can be used as UBO
963 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = VK_BIT(5), // Can be used as SSBO
964 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VK_BIT(6), // Can be used as source of fixed function index fetch (index buffer)
965 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = VK_BIT(7), // Can be used as source of fixed function vertex fetch (VBO)
966 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = VK_BIT(8), // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
967} VkBufferUsageFlagBits;
968
969// Buffer creation flags
970typedef VkFlags VkBufferCreateFlags;
971typedef enum VkBufferCreateFlagBits_
972{
973 VK_BUFFER_CREATE_SHAREABLE_BIT = VK_BIT(0), // Buffer should be shareable
974 VK_BUFFER_CREATE_SPARSE_BIT = VK_BIT(1), // Buffer should support sparse backing
975} VkBufferCreateFlagBits;
976
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]977// Image usage flags
978typedef VkFlags VkImageUsageFlags;
979typedef enum VkImageUsageFlagBits_
980{
981 VK_IMAGE_USAGE_GENERAL = 0, // No special usage
982 VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0), // Can be used as a source of transfer operations
983 VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1), // Can be used as a destination of transfer operations
984 VK_IMAGE_USAGE_SAMPLED_BIT = VK_BIT(2), // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
985 VK_IMAGE_USAGE_STORAGE_BIT = VK_BIT(3), // Can be used as storage image (STORAGE_IMAGE descriptor type)
986 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = VK_BIT(4), // Can be used as framebuffer color attachment
987 VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = VK_BIT(5), // Can be used as framebuffer depth/stencil attachment
988 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = VK_BIT(6), // Image data not needed outside of rendering
989} VkImageUsageFlagBits;
990
991// Image creation flags
992typedef VkFlags VkImageCreateFlags;
993typedef enum VkImageCreateFlagBits_
994{
995 VK_IMAGE_CREATE_INVARIANT_DATA_BIT = VK_BIT(0),
996 VK_IMAGE_CREATE_CLONEABLE_BIT = VK_BIT(1),
997 VK_IMAGE_CREATE_SHAREABLE_BIT = VK_BIT(2), // Image should be shareable
998 VK_IMAGE_CREATE_SPARSE_BIT = VK_BIT(3), // Image should support sparse backing
999 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VK_BIT(4), // Allows image views to have different format than the base image
1000 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = VK_BIT(5), // Allows creating image views with cube type from the created image
1001} VkImageCreateFlagBits;
1002
1003// Depth-stencil view creation flags
1004typedef VkFlags VkDepthStencilViewCreateFlags;
1005typedef enum VkDepthStencilViewCreateFlagBits_
1006{
1007 VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = VK_BIT(0),
1008 VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = VK_BIT(1),
1009} VkDepthStencilViewCreateFlagBits;
1010
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]1011// Shader creation flags
1012typedef VkFlags VkShaderCreateFlags;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1013
1014// Channel flags
1015typedef VkFlags VkChannelFlags;
1016typedef enum VkChannelFlagBits_
1017{
1018 VK_CHANNEL_R_BIT = VK_BIT(0),
1019 VK_CHANNEL_G_BIT = VK_BIT(1),
1020 VK_CHANNEL_B_BIT = VK_BIT(2),
1021 VK_CHANNEL_A_BIT = VK_BIT(3),
1022} VkChannelFlagBits;
1023
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]1024// Pipeline creation flags
1025typedef VkFlags VkPipelineCreateFlags;
1026typedef enum VkPipelineCreateFlagBits_
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1027{
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]1028 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VK_BIT(0),
1029 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VK_BIT(1),
1030} VkPipelineCreateFlagBits;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1031
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]1032// Shader stage flags
1033typedef VkFlags VkShaderStageFlags;
1034typedef enum VkShaderStageFlagBits_
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1035{
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]1036 VK_SHADER_STAGE_VERTEX_BIT = VK_BIT(0),
1037 VK_SHADER_STAGE_TESS_CONTROL_BIT = VK_BIT(1),
1038 VK_SHADER_STAGE_TESS_EVALUATION_BIT = VK_BIT(2),
1039 VK_SHADER_STAGE_GEOMETRY_BIT = VK_BIT(3),
1040 VK_SHADER_STAGE_FRAGMENT_BIT = VK_BIT(4),
1041 VK_SHADER_STAGE_COMPUTE_BIT = VK_BIT(5),
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1042
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]1043 VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
1044} VkShaderStageFlagBits;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1045
1046// Command buffer creation flags
1047typedef VkFlags VkCmdBufferCreateFlags;
1048
1049// Command buffer optimization flags
1050typedef VkFlags VkCmdBufferOptimizeFlags;
1051typedef enum VkCmdBufferOptimizeFlagBits_
1052{
1053 VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = VK_BIT(0),
1054 VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = VK_BIT(1),
1055 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = VK_BIT(2),
1056 VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = VK_BIT(3),
1057} VkCmdBufferOptimizeFlagBits;
1058
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]1059// Query control flags
1060typedef VkFlags VkQueryControlFlags;
1061typedef enum VkQueryControlFlagBits_
1062{
1063 VK_QUERY_CONTROL_CONSERVATIVE_BIT = VK_BIT(0), // Allow conservative results to be collected by the query
1064} VkQueryControlFlagBits;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1065
Jason Ekstrand1b7b5802015-07-06 16:11:05 -0700[diff] [blame^]1066// Memory output flags passed to resource transition commands
1067typedef VkFlags VkMemoryOutputFlags;
1068typedef enum VkMemoryOutputFlagBits_
1069{
1070 VK_MEMORY_OUTPUT_CPU_WRITE_BIT = VK_BIT(0), // Controls output coherency of CPU writes
1071 VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = VK_BIT(1), // Controls output coherency of generic shader writes
1072 VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = VK_BIT(2), // Controls output coherency of color attachment writes
1073 VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(3), // Controls output coherency of depth/stencil attachment writes
1074 VK_MEMORY_OUTPUT_TRANSFER_BIT = VK_BIT(4), // Controls output coherency of transfer operations
1075} VkMemoryOutputFlagBits;
1076
1077// Memory input flags passed to resource transition commands
1078typedef VkFlags VkMemoryInputFlags;
1079typedef enum VkMemoryInputFlagBits_
1080{
1081 VK_MEMORY_INPUT_CPU_READ_BIT = VK_BIT(0), // Controls input coherency of CPU reads
1082 VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = VK_BIT(1), // Controls input coherency of indirect command reads
1083 VK_MEMORY_INPUT_INDEX_FETCH_BIT = VK_BIT(2), // Controls input coherency of index fetches
1084 VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = VK_BIT(3), // Controls input coherency of vertex attribute fetches
1085 VK_MEMORY_INPUT_UNIFORM_READ_BIT = VK_BIT(4), // Controls input coherency of uniform buffer reads
1086 VK_MEMORY_INPUT_SHADER_READ_BIT = VK_BIT(5), // Controls input coherency of generic shader reads
1087 VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = VK_BIT(6), // Controls input coherency of color attachment reads
1088 VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(7), // Controls input coherency of depth/stencil attachment reads
1089 VK_MEMORY_INPUT_TRANSFER_BIT = VK_BIT(8), // Controls input coherency of transfer operations
1090} VkMemoryInputFlagBits;
1091
1092typedef enum VkProvokingVertex_
1093{
1094 VK_PROVOKING_VERTEX_FIRST = 0x00000000,
1095 VK_PROVOKING_VERTEX_LAST = 0x00000001,
1096
1097 VK_ENUM_RANGE(PROVOKING_VERTEX, FIRST, LAST)
1098} VkProvokingVertex;
1099
1100typedef enum VkCoordinateOrigin_
1101{
1102 VK_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000,
1103 VK_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001,
1104
1105 VK_ENUM_RANGE(COORDINATE_ORIGIN, UPPER_LEFT, LOWER_LEFT)
1106} VkCoordinateOrigin;
1107
1108typedef enum VkDepthMode_
1109{
1110 VK_DEPTH_MODE_ZERO_TO_ONE = 0x00000000,
1111 VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001,
1112
1113 VK_ENUM_RANGE(DEPTH_MODE, ZERO_TO_ONE, NEGATIVE_ONE_TO_ONE)
1114} VkDepthMode;
1115
1116typedef enum VkPhysicalDeviceInfoType_
1117{
1118 // Info type for vkGetPhysicalDeviceInfo()
1119 VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES = 0x00000000,
1120 VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE = 0x00000001,
1121 VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES = 0x00000002,
1122 VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES = 0x00000003,
1123
1124 VK_ENUM_RANGE(PHYSICAL_DEVICE_INFO_TYPE, PROPERTIES, MEMORY_PROPERTIES)
1125} VkPhysicalDeviceInfoType;
1126
1127typedef enum VkExtensionInfoType_
1128{
1129 // Info type for vkGetGlobalExtensionInfo() and vkGetPhysicalDeviceExtensionInfo()
1130 VK_EXTENSION_INFO_TYPE_COUNT = 0x00000000,
1131 VK_EXTENSION_INFO_TYPE_PROPERTIES = 0x00000001,
1132
1133 VK_ENUM_RANGE(EXTENSION_INFO_TYPE, COUNT, PROPERTIES)
1134} VkExtensionInfoType;
1135
1136typedef enum VkFormatInfoType_
1137{
1138 // Info type for vkGetFormatInfo()
1139 VK_FORMAT_INFO_TYPE_PROPERTIES = 0x00000000,
1140
1141 VK_ENUM_RANGE(FORMAT_INFO_TYPE, PROPERTIES, PROPERTIES)
1142} VkFormatInfoType;
1143
1144typedef enum VkSubresourceInfoType_
1145{
1146 // Info type for vkGetImageSubresourceInfo()
1147 VK_SUBRESOURCE_INFO_TYPE_LAYOUT = 0x00000000,
1148
1149 VK_ENUM_RANGE(SUBRESOURCE_INFO_TYPE, LAYOUT, LAYOUT)
1150} VkSubresourceInfoType;
1151
1152typedef enum VkObjectInfoType_
1153{
1154 // Info type for vkGetObjectInfo()
1155 VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000,
1156 VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001,
1157
1158 VK_ENUM_RANGE(OBJECT_INFO_TYPE, MEMORY_ALLOCATION_COUNT, MEMORY_REQUIREMENTS)
1159} VkObjectInfoType;
1160
1161
1162// Physical device compatibility flags
1163typedef VkFlags VkPhysicalDeviceCompatibilityFlags;
1164typedef enum VkPhysicalDeviceCompatibilityFlagBits_
1165{
1166 VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT = VK_BIT(0),
1167 VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT = VK_BIT(1),
1168 VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT = VK_BIT(2),
1169 VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT = VK_BIT(3),
1170 VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT = VK_BIT(4),
1171 VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT = VK_BIT(5),
1172 VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT = VK_BIT(6),
1173} VkPhysicalDeviceCompatibilityFlagBits;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1174
1175// ------------------------------------------------------------------------------------------------
1176// Vulkan structures
1177
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1178typedef struct {
1179 VkStructureType sType;
1180 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1181 const char* pAppName;
1182 uint32_t appVersion;
1183 const char* pEngineName;
1184 uint32_t engineVersion;
1185 uint32_t apiVersion;
1186} VkApplicationInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1187
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1188typedef void* (VKAPI *PFN_vkAllocFunction)(
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1189 void* pUserData,
1190 size_t size,
1191 size_t alignment,
1192 VkSystemAllocType allocType);
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1193
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1194typedef void (VKAPI *PFN_vkFreeFunction)(
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1195 void* pUserData,
1196 void* pMem);
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1197
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1198typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1199 void* pUserData;
1200 PFN_vkAllocFunction pfnAlloc;
1201 PFN_vkFreeFunction pfnFree;
1202} VkAllocCallbacks;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1203
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1204typedef struct {
1205 VkStructureType sType;
1206 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1207 const VkApplicationInfo* pAppInfo;
1208 const VkAllocCallbacks* pAllocCb;
1209 uint32_t extensionCount;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1210 const char*const* ppEnabledExtensionNames;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1211} VkInstanceCreateInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1212
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1213typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1214 uint32_t apiVersion;
1215 uint32_t driverVersion;
1216 uint32_t vendorId;
1217 uint32_t deviceId;
1218 VkPhysicalDeviceType deviceType;
1219 char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
1220 VkDeviceSize maxInlineMemoryUpdateSize;
1221 uint32_t maxBoundDescriptorSets;
1222 uint32_t maxThreadGroupSize;
1223 uint64_t timestampFrequency;
1224 bool32_t multiColorAttachmentClears;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1225 uint32_t maxDescriptorSets;
1226 uint32_t maxViewports;
1227 uint32_t maxColorAttachments;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1228} VkPhysicalDeviceProperties;
1229
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1230typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1231 float maxDeviceClock;
1232 float aluPerClock;
1233 float texPerClock;
1234 float primsPerClock;
1235 float pixelsPerClock;
1236} VkPhysicalDevicePerformance;
1237
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1238typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1239 VkPhysicalDeviceCompatibilityFlags compatibilityFlags;
1240} VkPhysicalDeviceCompatibilityInfo;
1241
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1242typedef struct {
1243 VkQueueFlags queueFlags;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1244 uint32_t queueCount;
1245 bool32_t supportsTimestamps;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1246} VkPhysicalDeviceQueueProperties;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1247
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1248typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1249 bool32_t supportsMigration;
1250 bool32_t supportsPinning;
1251} VkPhysicalDeviceMemoryProperties;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1252
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1253typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1254 uint32_t queueNodeIndex;
1255 uint32_t queueCount;
1256} VkDeviceQueueCreateInfo;
1257
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1258typedef struct {
1259 VkStructureType sType;
1260 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1261 uint32_t queueRecordCount;
1262 const VkDeviceQueueCreateInfo* pRequestedQueues;
1263 uint32_t extensionCount;
1264 const char*const* ppEnabledExtensionNames;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1265 VkDeviceCreateFlags flags;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1266} VkDeviceCreateInfo;
1267
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1268typedef struct {
1269 char extName[VK_MAX_EXTENSION_NAME];
1270 uint32_t version;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1271} VkExtensionProperties;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1272
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1273typedef struct {
1274 VkStructureType sType;
1275 const void* pNext;
1276 VkDeviceSize allocationSize;
1277 VkMemoryPropertyFlags memProps;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1278} VkMemoryAllocInfo;
1279
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1280typedef struct {
1281 VkStructureType sType;
1282 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1283 VkDeviceMemory sharedMem;
1284} VkMemoryOpenInfo;
1285
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1286typedef struct {
1287 VkDeviceSize size;
1288 VkDeviceSize alignment;
1289 VkDeviceSize granularity;
1290 VkMemoryPropertyFlags memPropsAllowed;
1291 VkMemoryPropertyFlags memPropsRequired;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1292} VkMemoryRequirements;
1293
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1294typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1295 VkImageAspect aspect;
1296 uint32_t mipLevel;
1297 uint32_t arraySlice;
1298} VkImageSubresource;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1299
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1300typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1301 int32_t x;
1302 int32_t y;
1303 int32_t z;
1304} VkOffset3D;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1305
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1306typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1307 int32_t width;
1308 int32_t height;
1309 int32_t depth;
1310} VkExtent3D;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1311
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1312typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1313 VkImageSubresource subresource;
1314 VkOffset3D offset;
1315 VkExtent3D extent;
1316} VkImageMemoryBindInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1317
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1318typedef struct {
1319 VkStructureType sType;
1320 const void* pNext;
1321 VkFenceCreateFlags flags;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1322} VkFenceCreateInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1323
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1324typedef struct {
1325 VkStructureType sType;
1326 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1327 uint32_t initialCount;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1328 VkSemaphoreCreateFlags flags;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1329} VkSemaphoreCreateInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1330
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1331typedef struct {
1332 VkStructureType sType;
1333 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1334 VkSemaphore sharedSemaphore;
1335} VkSemaphoreOpenInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1336
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1337typedef struct {
1338 VkStructureType sType;
1339 const void* pNext;
1340 VkEventCreateFlags flags;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1341} VkEventCreateInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1342
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1343typedef struct {
1344 VkStructureType sType;
1345 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1346 VkQueryType queryType;
1347 uint32_t slots;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1348 VkQueryPipelineStatisticFlags pipelineStatistics;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1349} VkQueryPoolCreateInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1350
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1351typedef struct {
1352 VkStructureType sType;
1353 const void* pNext;
1354 VkDeviceSize size;
1355 VkBufferUsageFlags usage;
1356 VkBufferCreateFlags flags;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1357} VkBufferCreateInfo;
1358
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1359typedef struct {
1360 VkStructureType sType;
1361 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1362 VkBuffer buffer;
1363 VkBufferViewType viewType;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1364 VkFormat format;
1365 VkDeviceSize offset;
1366 VkDeviceSize range;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1367} VkBufferViewCreateInfo;
1368
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1369typedef struct {
1370 VkStructureType sType;
1371 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1372 VkImageType imageType;
1373 VkFormat format;
1374 VkExtent3D extent;
1375 uint32_t mipLevels;
1376 uint32_t arraySize;
1377 uint32_t samples;
1378 VkImageTiling tiling;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1379 VkImageUsageFlags usage;
1380 VkImageCreateFlags flags;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1381} VkImageCreateInfo;
1382
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1383typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1384 VkImage originalImage;
1385} VkPeerImageOpenInfo;
1386
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1387typedef struct {
1388 VkDeviceSize offset;
1389 VkDeviceSize size;
1390 VkDeviceSize rowPitch;
1391 VkDeviceSize depthPitch;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1392} VkSubresourceLayout;
1393
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1394typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1395 VkChannelSwizzle r;
1396 VkChannelSwizzle g;
1397 VkChannelSwizzle b;
1398 VkChannelSwizzle a;
1399} VkChannelMapping;
1400
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1401typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1402 VkImageAspect aspect;
1403 uint32_t baseMipLevel;
1404 uint32_t mipLevels;
1405 uint32_t baseArraySlice;
1406 uint32_t arraySize;
1407} VkImageSubresourceRange;
1408
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1409typedef struct {
1410 VkStructureType sType;
1411 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1412 VkImage image;
1413 VkImageViewType viewType;
1414 VkFormat format;
1415 VkChannelMapping channels;
1416 VkImageSubresourceRange subresourceRange;
1417 float minLod;
1418} VkImageViewCreateInfo;
1419
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1420typedef struct {
1421 VkStructureType sType;
1422 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1423 VkImage image;
1424 VkFormat format;
1425 uint32_t mipLevel;
1426 uint32_t baseArraySlice;
1427 uint32_t arraySize;
1428 VkImage msaaResolveImage;
1429 VkImageSubresourceRange msaaResolveSubResource;
1430} VkColorAttachmentViewCreateInfo;
1431
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1432typedef struct {
1433 VkStructureType sType;
1434 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1435 VkImage image;
1436 uint32_t mipLevel;
1437 uint32_t baseArraySlice;
1438 uint32_t arraySize;
1439 VkImage msaaResolveImage;
1440 VkImageSubresourceRange msaaResolveSubResource;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1441 VkDepthStencilViewCreateFlags flags;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1442} VkDepthStencilViewCreateInfo;
1443
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1444typedef struct {
1445 VkStructureType sType;
1446 const void* pNext;
1447 size_t codeSize;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1448 const void* pCode;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1449 VkShaderCreateFlags flags;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1450} VkShaderCreateInfo;
1451
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1452typedef struct {
1453 uint32_t constantId;
1454 uint32_t offset;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1455} VkSpecializationMapEntry;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1456
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1457typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1458 uint32_t bufferId;
1459 size_t bufferSize;
1460 const void* pBufferData;
1461} VkLinkConstBuffer;
1462
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1463typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1464 uint32_t mapEntryCount;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1465 const VkSpecializationMapEntry* pMap;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1466 const void* pData;
1467} VkSpecializationInfo;
1468
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1469typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1470 VkShaderStage stage;
1471 VkShader shader;
1472 uint32_t linkConstBufferCount;
1473 const VkLinkConstBuffer* pLinkConstBufferInfo;
1474 const VkSpecializationInfo* pSpecializationInfo;
1475} VkPipelineShader;
1476
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1477typedef struct {
1478 VkStructureType sType;
1479 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1480 VkPipelineShader shader;
1481} VkPipelineShaderStageCreateInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1482
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1483typedef struct {
1484 uint32_t binding;
1485 uint32_t strideInBytes;
1486 VkVertexInputStepRate stepRate;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1487} VkVertexInputBindingDescription;
1488
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1489typedef struct {
1490 uint32_t location;
1491 uint32_t binding;
1492 VkFormat format;
1493 uint32_t offsetInBytes;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1494} VkVertexInputAttributeDescription;
1495
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1496typedef struct {
1497 VkStructureType sType;
1498 const void* pNext;
1499 uint32_t bindingCount;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1500 const VkVertexInputBindingDescription* pVertexBindingDescriptions;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1501 uint32_t attributeCount;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1502 const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1503} VkPipelineVertexInputCreateInfo;
1504
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1505typedef struct {
1506 VkStructureType sType;
1507 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1508 VkPrimitiveTopology topology;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1509 bool32_t disableVertexReuse;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1510 bool32_t primitiveRestartEnable;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1511 uint32_t primitiveRestartIndex;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1512} VkPipelineIaStateCreateInfo;
1513
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1514typedef struct {
1515 VkStructureType sType;
1516 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1517 uint32_t patchControlPoints;
1518} VkPipelineTessStateCreateInfo;
1519
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1520typedef struct {
1521 VkStructureType sType;
1522 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1523 uint32_t viewportCount;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1524 VkCoordinateOrigin clipOrigin;
1525 VkDepthMode depthMode;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1526} VkPipelineVpStateCreateInfo;
1527
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1528typedef struct {
1529 VkStructureType sType;
1530 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1531 bool32_t depthClipEnable;
1532 bool32_t rasterizerDiscardEnable;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1533 bool32_t programPointSize;
1534 VkCoordinateOrigin pointOrigin;
1535 VkProvokingVertex provokingVertex;
1536 VkFillMode fillMode;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1537 VkCullMode cullMode;
1538 VkFrontFace frontFace;
1539} VkPipelineRsStateCreateInfo;
1540
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1541typedef struct {
1542 VkStructureType sType;
1543 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1544 uint32_t samples;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1545 bool32_t multisampleEnable;
1546 bool32_t sampleShadingEnable;
1547 float minSampleShading;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1548 VkSampleMask sampleMask;
1549} VkPipelineMsStateCreateInfo;
1550
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1551typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1552 VkStencilOp stencilFailOp;
1553 VkStencilOp stencilPassOp;
1554 VkStencilOp stencilDepthFailOp;
1555 VkCompareOp stencilCompareOp;
1556} VkStencilOpState;
1557
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1558typedef struct {
1559 VkStructureType sType;
1560 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1561 VkFormat format;
1562 bool32_t depthTestEnable;
1563 bool32_t depthWriteEnable;
1564 VkCompareOp depthCompareOp;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1565 bool32_t depthBoundsEnable;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1566 bool32_t stencilTestEnable;
1567 VkStencilOpState front;
1568 VkStencilOpState back;
1569} VkPipelineDsStateCreateInfo;
1570
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1571typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1572 bool32_t blendEnable;
1573 VkFormat format;
1574 VkBlend srcBlendColor;
1575 VkBlend destBlendColor;
1576 VkBlendOp blendOpColor;
1577 VkBlend srcBlendAlpha;
1578 VkBlend destBlendAlpha;
1579 VkBlendOp blendOpAlpha;
1580 VkChannelFlags channelWriteMask;
1581} VkPipelineCbAttachmentState;
1582
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1583typedef struct {
1584 VkStructureType sType;
1585 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1586 bool32_t alphaToCoverageEnable;
1587 bool32_t logicOpEnable;
1588 VkLogicOp logicOp;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1589 uint32_t attachmentCount;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1590 const VkPipelineCbAttachmentState* pAttachments;
1591} VkPipelineCbStateCreateInfo;
1592
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1593typedef struct {
1594 VkStructureType sType;
1595 const void* pNext;
1596 VkPipelineCreateFlags flags;
1597 VkPipelineLayout layout;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1598} VkGraphicsPipelineCreateInfo;
1599
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1600typedef struct {
1601 VkStructureType sType;
1602 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1603 VkPipelineShader cs;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1604 VkPipelineCreateFlags flags;
1605 VkPipelineLayout layout;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1606} VkComputePipelineCreateInfo;
1607
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1608typedef struct {
1609 VkStructureType sType;
1610 const void* pNext;
1611 uint32_t descriptorSetCount;
1612 const VkDescriptorSetLayout* pSetLayouts;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1613} VkPipelineLayoutCreateInfo;
1614
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1615typedef struct {
1616 VkStructureType sType;
1617 const void* pNext;
1618 VkTexFilter magFilter;
1619 VkTexFilter minFilter;
1620 VkTexMipmapMode mipMode;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1621 VkTexAddress addressU;
1622 VkTexAddress addressV;
1623 VkTexAddress addressW;
1624 float mipLodBias;
1625 uint32_t maxAnisotropy;
1626 VkCompareOp compareOp;
1627 float minLod;
1628 float maxLod;
1629 VkBorderColor borderColor;
1630} VkSamplerCreateInfo;
1631
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1632typedef struct {
1633 VkDescriptorType descriptorType;
1634 uint32_t count;
1635 VkShaderStageFlags stageFlags;
1636 const VkSampler* pImmutableSamplers;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1637} VkDescriptorSetLayoutBinding;
1638
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1639typedef struct {
1640 VkStructureType sType;
1641 const void* pNext;
1642 uint32_t count;
1643 const VkDescriptorSetLayoutBinding* pBinding;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1644} VkDescriptorSetLayoutCreateInfo;
1645
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1646typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1647 VkDescriptorType type;
1648 uint32_t count;
1649} VkDescriptorTypeCount;
1650
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1651typedef struct {
1652 VkStructureType sType;
1653 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1654 uint32_t count;
1655 const VkDescriptorTypeCount* pTypeCount;
1656} VkDescriptorPoolCreateInfo;
1657
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1658typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1659 float originX;
1660 float originY;
1661 float width;
1662 float height;
1663 float minDepth;
1664 float maxDepth;
1665} VkViewport;
1666
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1667typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1668 int32_t x;
1669 int32_t y;
1670} VkOffset2D;
1671
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1672typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1673 int32_t width;
1674 int32_t height;
1675} VkExtent2D;
1676
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1677typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1678 VkOffset2D offset;
1679 VkExtent2D extent;
1680} VkRect;
1681
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1682typedef struct {
1683 VkStructureType sType;
1684 const void* pNext;
1685 uint32_t viewportAndScissorCount;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1686 const VkViewport* pViewports;
1687 const VkRect* pScissors;
1688} VkDynamicVpStateCreateInfo;
1689
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1690typedef struct {
1691 VkStructureType sType;
1692 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1693 float depthBias;
1694 float depthBiasClamp;
1695 float slopeScaledDepthBias;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1696 float pointSize;
1697 float pointFadeThreshold;
1698 float lineWidth;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1699} VkDynamicRsStateCreateInfo;
1700
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1701typedef struct {
1702 VkStructureType sType;
1703 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1704 float blendConst[4];
1705} VkDynamicCbStateCreateInfo;
1706
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1707typedef struct {
1708 VkStructureType sType;
1709 const void* pNext;
1710 float minDepth;
1711 float maxDepth;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1712 uint32_t stencilReadMask;
1713 uint32_t stencilWriteMask;
1714 uint32_t stencilFrontRef;
1715 uint32_t stencilBackRef;
1716} VkDynamicDsStateCreateInfo;
1717
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1718typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1719 VkColorAttachmentView view;
1720 VkImageLayout layout;
1721} VkColorAttachmentBindInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1722
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1723typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1724 VkDepthStencilView view;
1725 VkImageLayout layout;
1726} VkDepthStencilBindInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1727
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1728typedef struct {
1729 VkStructureType sType;
1730 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1731 uint32_t colorAttachmentCount;
1732 const VkColorAttachmentBindInfo* pColorAttachments;
1733 const VkDepthStencilBindInfo* pDepthStencilAttachment;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1734 uint32_t sampleCount;
1735 uint32_t width;
1736 uint32_t height;
1737 uint32_t layers;
1738} VkFramebufferCreateInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1739
1740// Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared.
1741typedef union VkClearColorValue_
1742{
1743 float floatColor[4];
1744 uint32_t rawColor[4];
1745} VkClearColorValue;
1746
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1747typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1748 VkClearColorValue color;
1749 bool32_t useRawValue;
1750} VkClearColor;
1751
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1752typedef struct {
1753 VkStructureType sType;
1754 const void* pNext;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1755
1756 VkRect renderArea;
1757 uint32_t colorAttachmentCount;
1758 VkExtent2D extent;
1759 uint32_t sampleCount;
1760 uint32_t layers;
1761 const VkFormat* pColorFormats;
1762 const VkImageLayout* pColorLayouts;
1763 const VkAttachmentLoadOp* pColorLoadOps;
1764 const VkAttachmentStoreOp* pColorStoreOps;
1765 const VkClearColor* pColorLoadClearValues;
1766 VkFormat depthStencilFormat;
1767 VkImageLayout depthStencilLayout;
1768 VkAttachmentLoadOp depthLoadOp;
1769 float depthLoadClearValue;
1770 VkAttachmentStoreOp depthStoreOp;
1771 VkAttachmentLoadOp stencilLoadOp;
1772 uint32_t stencilLoadClearValue;
1773 VkAttachmentStoreOp stencilStoreOp;
1774} VkRenderPassCreateInfo;
1775
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1776typedef struct {
1777 VkStructureType sType;
1778 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1779 uint32_t queueNodeIndex;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1780 VkCmdBufferCreateFlags flags;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1781} VkCmdBufferCreateInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1782
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1783typedef struct {
1784 VkStructureType sType;
1785 const void* pNext;
1786 VkCmdBufferOptimizeFlags flags;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1787} VkCmdBufferBeginInfo;
1788
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1789typedef struct {
1790 VkDeviceSize srcOffset;
1791 VkDeviceSize destOffset;
1792 VkDeviceSize copySize;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1793} VkBufferCopy;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1794
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1795typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1796 VkImageSubresource srcSubresource;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1797 VkOffset3D srcOffset;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1798 VkImageSubresource destSubresource;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1799 VkOffset3D destOffset;
1800 VkExtent3D extent;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1801} VkImageCopy;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1802
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1803typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1804 VkImageSubresource srcSubresource;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1805 VkOffset3D srcOffset;
1806 VkExtent3D srcExtent;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1807 VkImageSubresource destSubresource;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1808 VkOffset3D destOffset;
1809 VkExtent3D destExtent;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1810} VkImageBlit;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1811
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1812typedef struct {
1813 VkDeviceSize bufferOffset;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1814 VkImageSubresource imageSubresource;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1815 VkOffset3D imageOffset;
1816 VkExtent3D imageExtent;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1817} VkBufferImageCopy;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1818
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1819typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1820 VkImageSubresource srcSubresource;
1821 VkOffset3D srcOffset;
1822 VkImageSubresource destSubresource;
1823 VkOffset3D destOffset;
1824 VkExtent3D extent;
1825} VkImageResolve;
1826
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1827typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1828 VkRenderPass renderPass;
1829 VkFramebuffer framebuffer;
1830} VkRenderPassBegin;
1831
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1832typedef struct {
1833 VkStructureType sType;
1834 const void* pNext;
1835 VkMemoryOutputFlags outputMask;
1836 VkMemoryInputFlags inputMask;
1837 VkBuffer buffer;
1838 VkDeviceSize offset;
1839 VkDeviceSize size;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1840} VkBufferMemoryBarrier;
1841
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1842typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1843 uint32_t x;
1844 uint32_t y;
1845 uint32_t z;
1846} VkDispatchIndirectCmd;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1847
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1848typedef struct {
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1849 uint32_t indexCount;
1850 uint32_t instanceCount;
1851 uint32_t firstIndex;
1852 int32_t vertexOffset;
1853 uint32_t firstInstance;
1854} VkDrawIndexedIndirectCmd;
1855
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1856typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1857 uint32_t vertexCount;
1858 uint32_t instanceCount;
1859 uint32_t firstVertex;
1860 uint32_t firstInstance;
1861} VkDrawIndirectCmd;
1862
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1863typedef struct {
1864 VkStructureType sType;
1865 const void* pNext;
1866 VkMemoryOutputFlags outputMask;
1867 VkMemoryInputFlags inputMask;
1868 VkImageLayout oldLayout;
1869 VkImageLayout newLayout;
1870 VkImage image;
1871 VkImageSubresourceRange subresourceRange;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1872} VkImageMemoryBarrier;
1873
1874// can be added to VkDeviceCreateInfo via pNext
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1875typedef struct {
1876 VkStructureType sType;
1877 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1878 uint32_t layerCount;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1879 const char *const* ppActiveLayerNames;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1880} VkLayerCreateInfo;
1881
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1882typedef struct {
1883 VkStructureType sType;
1884 const void* pNext;
1885 VkMemoryOutputFlags outputMask;
1886 VkMemoryInputFlags inputMask;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1887} VkMemoryBarrier;
1888
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1889typedef struct {
1890 VkStructureType sType;
1891 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1892 VkDeviceMemory originalMem;
1893} VkPeerMemoryOpenInfo;
1894
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1895typedef struct {
1896 VkFormatFeatureFlags linearTilingFeatures;
1897 VkFormatFeatureFlags optimalTilingFeatures;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1898} VkFormatProperties;
1899
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1900typedef struct {
1901 VkStructureType sType;
1902 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1903 VkBufferView view;
1904} VkBufferViewAttachInfo;
1905
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1906typedef struct {
1907 VkStructureType sType;
1908 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1909 VkImageView view;
1910 VkImageLayout layout;
1911} VkImageViewAttachInfo;
1912
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1913typedef struct {
1914 VkStructureType sType;
1915 const void* pNext;
1916 uint32_t binding;
1917 uint32_t arrayIndex;
1918 uint32_t count;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1919 const VkSampler* pSamplers;
1920} VkUpdateSamplers;
1921
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1922typedef struct {
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1923 VkSampler sampler;
1924 const VkImageViewAttachInfo* pImageView;
1925} VkSamplerImageViewInfo;
1926
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1927typedef struct {
1928 VkStructureType sType;
1929 const void* pNext;
1930 uint32_t binding;
1931 uint32_t arrayIndex;
1932 uint32_t count;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1933 const VkSamplerImageViewInfo* pSamplerImageViews;
1934} VkUpdateSamplerTextures;
1935
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1936typedef struct {
1937 VkStructureType sType;
1938 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1939 VkDescriptorType descriptorType;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1940 uint32_t binding;
1941 uint32_t arrayIndex;
1942 uint32_t count;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1943 const VkImageViewAttachInfo* pImageViews;
1944} VkUpdateImages;
1945
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1946typedef struct {
1947 VkStructureType sType;
1948 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1949 VkDescriptorType descriptorType;
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1950 uint32_t binding;
1951 uint32_t arrayIndex;
1952 uint32_t count;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1953 const VkBufferViewAttachInfo* pBufferViews;
1954} VkUpdateBuffers;
1955
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1956typedef struct {
1957 VkStructureType sType;
1958 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1959 VkDescriptorType descriptorType;
1960 VkDescriptorSet descriptorSet;
1961 uint32_t binding;
1962 uint32_t arrayElement;
1963 uint32_t count;
1964} VkUpdateAsCopy;
1965
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1966typedef struct {
1967 VkStructureType sType;
1968 const void* pNext;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1969
Jason Ekstrand0dc7d4a2015-07-06 15:19:04 -0700[diff] [blame]1970 VkRenderPassBegin renderPassContinue;
Jason Ekstrand19aabb52015-07-06 15:09:21 -0700[diff] [blame]1971} VkCmdBufferGraphicsBeginInfo;
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1972
1973// ------------------------------------------------------------------------------------------------
1974// API functions
1975typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
1976typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
1977typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
1978typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceInfo)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, size_t* pDataSize, void* pData);
1979typedef void * (VKAPI *PFN_vkGetProcAddr)(VkPhysicalDevice physicalDevice, const char * pName);
1980typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
1981typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
1982typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionInfo)(VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData);
1983typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionInfo)(VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData);
1984typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalDevice physicalDevice, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved);
1985typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue);
1986typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1987typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
1988typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
1989typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
1990typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem);
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1991typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
1992typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
1993typedef VkResult (VKAPI *PFN_vkFlushMappedMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size);
1994typedef VkResult (VKAPI *PFN_vkPinSystemMemory)(VkDevice device, const void* pSysMem, size_t memSize, VkDeviceMemory* pMem);
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]1995typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object);
1996typedef VkResult (VKAPI *PFN_vkGetObjectInfo)(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData);
1997typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemory)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset);
1998typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemoryRange)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
1999typedef VkResult (VKAPI *PFN_vkQueueBindImageMemoryRange)(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
2000typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
2001typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, VkFence* pFences);
2002typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
2003typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout);
2004typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
2005typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore);
2006typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore);
2007typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
2008typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
2009typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
2010typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
2011typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
2012typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags);
2013typedef VkResult (VKAPI *PFN_vkGetFormatInfo)(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData);
2014typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
2015typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
2016typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
2017typedef VkResult (VKAPI *PFN_vkGetImageSubresourceInfo)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData);
2018typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
2019typedef VkResult (VKAPI *PFN_vkCreateColorAttachmentView)(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView);
2020typedef VkResult (VKAPI *PFN_vkCreateDepthStencilView)(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView);
2021typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
2022typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipeline)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
2023typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelineDerivative)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline);
2024typedef VkResult (VKAPI *PFN_vkCreateComputePipeline)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
2025typedef VkResult (VKAPI *PFN_vkStorePipeline)(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData);
2026typedef VkResult (VKAPI *PFN_vkLoadPipeline)(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline);
2027typedef VkResult (VKAPI *PFN_vkLoadPipelineDerivative)(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline);
2028typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
2029typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
2030typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2031typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
2032typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
2033typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount);
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2034typedef void (VKAPI *PFN_vkUpdateDescriptors)(VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray);
2035typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState);
2036typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState);
2037typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState);
2038typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState);
2039typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
2040typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
2041typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
2042typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer);
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]2043typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
Jason Ekstrand2fb524b2015-07-06 15:37:17 -0700[diff] [blame]2044typedef void (VKAPI *PFN_vkCmdBindDynamicStateObject)(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject dynamicState);
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]2045typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
2046typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
2047typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
2048typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
2049typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
2050typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
2051typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
2052typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
2053typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
2054typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
2055typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
2056typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions);
2057typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
2058typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]2059typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
2060typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
2061typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2062typedef void (VKAPI *PFN_vkCmdClearDepthStencil)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2063typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
2064typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent);
2065typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent);
2066typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers);
2067typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers);
2068typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
2069typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
2070typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
2071typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset);
2072typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2073typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
2074typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]2075typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin);
2076typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer, VkRenderPass renderPass);
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2077
2078#ifdef VK_PROTOTYPES
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2079VkResult VKAPI vkCreateInstance(
2080 const VkInstanceCreateInfo* pCreateInfo,
2081 VkInstance* pInstance);
2082
2083VkResult VKAPI vkDestroyInstance(
2084 VkInstance instance);
2085
2086VkResult VKAPI vkEnumeratePhysicalDevices(
2087 VkInstance instance,
2088 uint32_t* pPhysicalDeviceCount,
2089 VkPhysicalDevice* pPhysicalDevices);
2090
2091VkResult VKAPI vkGetPhysicalDeviceInfo(
2092 VkPhysicalDevice physicalDevice,
2093 VkPhysicalDeviceInfoType infoType,
2094 size_t* pDataSize,
2095 void* pData);
2096
2097void * VKAPI vkGetProcAddr(
2098 VkPhysicalDevice physicalDevice,
2099 const char* pName);
2100
2101// Device functions
2102
2103VkResult VKAPI vkCreateDevice(
2104 VkPhysicalDevice physicalDevice,
2105 const VkDeviceCreateInfo* pCreateInfo,
2106 VkDevice* pDevice);
2107
2108VkResult VKAPI vkDestroyDevice(
2109 VkDevice device);
2110
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2111VkResult VKAPI vkGetGlobalExtensionInfo(
2112 VkExtensionInfoType infoType,
2113 uint32_t extensionIndex,
2114 size_t* pDataSize,
2115 void* pData);
2116
2117VkResult VKAPI vkGetPhysicalDeviceExtensionInfo(
2118 VkPhysicalDevice physicalDevice,
2119 VkExtensionInfoType infoType,
2120 uint32_t extensionIndex,
2121 size_t* pDataSize,
2122 void* pData);
2123
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2124VkResult VKAPI vkEnumerateLayers(
2125 VkPhysicalDevice physicalDevice,
2126 size_t maxStringSize,
2127 size_t* pLayerCount,
2128 char* const* pOutLayers,
2129 void* pReserved);
2130
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2131VkResult VKAPI vkGetDeviceQueue(
2132 VkDevice device,
2133 uint32_t queueNodeIndex,
2134 uint32_t queueIndex,
2135 VkQueue* pQueue);
2136
2137VkResult VKAPI vkQueueSubmit(
2138 VkQueue queue,
2139 uint32_t cmdBufferCount,
2140 const VkCmdBuffer* pCmdBuffers,
2141 VkFence fence);
2142
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2143VkResult VKAPI vkQueueWaitIdle(
2144 VkQueue queue);
2145
2146VkResult VKAPI vkDeviceWaitIdle(
2147 VkDevice device);
2148
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2149VkResult VKAPI vkAllocMemory(
2150 VkDevice device,
2151 const VkMemoryAllocInfo* pAllocInfo,
2152 VkDeviceMemory* pMem);
2153
2154VkResult VKAPI vkFreeMemory(
2155 VkDevice device,
2156 VkDeviceMemory mem);
2157
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2158VkResult VKAPI vkMapMemory(
2159 VkDevice device,
2160 VkDeviceMemory mem,
2161 VkDeviceSize offset,
2162 VkDeviceSize size,
2163 VkMemoryMapFlags flags,
2164 void** ppData);
2165
2166VkResult VKAPI vkUnmapMemory(
2167 VkDevice device,
2168 VkDeviceMemory mem);
2169
2170VkResult VKAPI vkFlushMappedMemory(
2171 VkDevice device,
2172 VkDeviceMemory mem,
2173 VkDeviceSize offset,
2174 VkDeviceSize size);
2175
2176VkResult VKAPI vkPinSystemMemory(
2177 VkDevice device,
2178 const void* pSysMem,
2179 size_t memSize,
2180 VkDeviceMemory* pMem);
2181
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2182VkResult VKAPI vkDestroyObject(
2183 VkDevice device,
2184 VkObjectType objType,
2185 VkObject object);
2186
2187VkResult VKAPI vkGetObjectInfo(
2188 VkDevice device,
2189 VkObjectType objType,
2190 VkObject object,
2191 VkObjectInfoType infoType,
2192 size_t* pDataSize,
2193 void* pData);
2194
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2195VkResult VKAPI vkQueueBindObjectMemory(
2196 VkQueue queue,
2197 VkObjectType objType,
2198 VkObject object,
2199 uint32_t allocationIdx,
2200 VkDeviceMemory mem,
2201 VkDeviceSize memOffset);
2202
2203VkResult VKAPI vkQueueBindObjectMemoryRange(
2204 VkQueue queue,
2205 VkObjectType objType,
2206 VkObject object,
2207 uint32_t allocationIdx,
2208 VkDeviceSize rangeOffset,
2209 VkDeviceSize rangeSize,
2210 VkDeviceMemory mem,
2211 VkDeviceSize memOffset);
2212
2213VkResult VKAPI vkQueueBindImageMemoryRange(
2214 VkQueue queue,
2215 VkImage image,
2216 uint32_t allocationIdx,
2217 const VkImageMemoryBindInfo* pBindInfo,
2218 VkDeviceMemory mem,
2219 VkDeviceSize memOffset);
2220
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2221VkResult VKAPI vkCreateFence(
2222 VkDevice device,
2223 const VkFenceCreateInfo* pCreateInfo,
2224 VkFence* pFence);
2225
2226VkResult VKAPI vkResetFences(
2227 VkDevice device,
2228 uint32_t fenceCount,
2229 VkFence* pFences);
2230
2231VkResult VKAPI vkGetFenceStatus(
2232 VkDevice device,
2233 VkFence fence);
2234
2235VkResult VKAPI vkWaitForFences(
2236 VkDevice device,
2237 uint32_t fenceCount,
2238 const VkFence* pFences,
2239 bool32_t waitAll,
2240 uint64_t timeout); // timeout in nanoseconds
2241
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2242VkResult VKAPI vkCreateSemaphore(
2243 VkDevice device,
2244 const VkSemaphoreCreateInfo* pCreateInfo,
2245 VkSemaphore* pSemaphore);
2246
2247VkResult VKAPI vkQueueSignalSemaphore(
2248 VkQueue queue,
2249 VkSemaphore semaphore);
2250
2251VkResult VKAPI vkQueueWaitSemaphore(
2252 VkQueue queue,
2253 VkSemaphore semaphore);
2254
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2255VkResult VKAPI vkCreateEvent(
2256 VkDevice device,
2257 const VkEventCreateInfo* pCreateInfo,
2258 VkEvent* pEvent);
2259
2260VkResult VKAPI vkGetEventStatus(
2261 VkDevice device,
2262 VkEvent event);
2263
2264VkResult VKAPI vkSetEvent(
2265 VkDevice device,
2266 VkEvent event);
2267
2268VkResult VKAPI vkResetEvent(
2269 VkDevice device,
2270 VkEvent event);
2271
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2272VkResult VKAPI vkCreateQueryPool(
2273 VkDevice device,
2274 const VkQueryPoolCreateInfo* pCreateInfo,
2275 VkQueryPool* pQueryPool);
2276
2277VkResult VKAPI vkGetQueryPoolResults(
2278 VkDevice device,
2279 VkQueryPool queryPool,
2280 uint32_t startQuery,
2281 uint32_t queryCount,
2282 size_t* pDataSize,
2283 void* pData,
2284 VkQueryResultFlags flags);
2285
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2286VkResult VKAPI vkGetFormatInfo(
2287 VkDevice device,
2288 VkFormat format,
2289 VkFormatInfoType infoType,
2290 size_t* pDataSize,
2291 void* pData);
2292
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2293VkResult VKAPI vkCreateBuffer(
2294 VkDevice device,
2295 const VkBufferCreateInfo* pCreateInfo,
2296 VkBuffer* pBuffer);
2297
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2298VkResult VKAPI vkCreateBufferView(
2299 VkDevice device,
2300 const VkBufferViewCreateInfo* pCreateInfo,
2301 VkBufferView* pView);
2302
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2303VkResult VKAPI vkCreateImage(
2304 VkDevice device,
2305 const VkImageCreateInfo* pCreateInfo,
2306 VkImage* pImage);
2307
2308VkResult VKAPI vkGetImageSubresourceInfo(
2309 VkDevice device,
2310 VkImage image,
2311 const VkImageSubresource* pSubresource,
2312 VkSubresourceInfoType infoType,
2313 size_t* pDataSize,
2314 void* pData);
2315
2316// Image view functions
2317
2318VkResult VKAPI vkCreateImageView(
2319 VkDevice device,
2320 const VkImageViewCreateInfo* pCreateInfo,
2321 VkImageView* pView);
2322
2323VkResult VKAPI vkCreateColorAttachmentView(
2324 VkDevice device,
2325 const VkColorAttachmentViewCreateInfo* pCreateInfo,
2326 VkColorAttachmentView* pView);
2327
2328VkResult VKAPI vkCreateDepthStencilView(
2329 VkDevice device,
2330 const VkDepthStencilViewCreateInfo* pCreateInfo,
2331 VkDepthStencilView* pView);
2332
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2333VkResult VKAPI vkCreateShader(
2334 VkDevice device,
2335 const VkShaderCreateInfo* pCreateInfo,
2336 VkShader* pShader);
2337
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2338VkResult VKAPI vkCreateGraphicsPipeline(
2339 VkDevice device,
2340 const VkGraphicsPipelineCreateInfo* pCreateInfo,
2341 VkPipeline* pPipeline);
2342
2343VkResult VKAPI vkCreateGraphicsPipelineDerivative(
2344 VkDevice device,
2345 const VkGraphicsPipelineCreateInfo* pCreateInfo,
2346 VkPipeline basePipeline,
2347 VkPipeline* pPipeline);
2348
2349VkResult VKAPI vkCreateComputePipeline(
2350 VkDevice device,
2351 const VkComputePipelineCreateInfo* pCreateInfo,
2352 VkPipeline* pPipeline);
2353
2354VkResult VKAPI vkStorePipeline(
2355 VkDevice device,
2356 VkPipeline pipeline,
2357 size_t* pDataSize,
2358 void* pData);
2359
2360VkResult VKAPI vkLoadPipeline(
2361 VkDevice device,
2362 size_t dataSize,
2363 const void* pData,
2364 VkPipeline* pPipeline);
2365
2366VkResult VKAPI vkLoadPipelineDerivative(
2367 VkDevice device,
2368 size_t dataSize,
2369 const void* pData,
2370 VkPipeline basePipeline,
2371 VkPipeline* pPipeline);
2372
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2373VkResult VKAPI vkCreatePipelineLayout(
2374 VkDevice device,
2375 const VkPipelineLayoutCreateInfo* pCreateInfo,
2376 VkPipelineLayout* pPipelineLayout);
2377
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2378VkResult VKAPI vkCreateSampler(
2379 VkDevice device,
2380 const VkSamplerCreateInfo* pCreateInfo,
2381 VkSampler* pSampler);
2382
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2383VkResult VKAPI vkCreateDescriptorSetLayout(
2384 VkDevice device,
2385 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
2386 VkDescriptorSetLayout* pSetLayout);
2387
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2388VkResult VKAPI vkCreateDescriptorPool(
2389 VkDevice device,
2390 VkDescriptorPoolUsage poolUsage,
2391 uint32_t maxSets,
2392 const VkDescriptorPoolCreateInfo* pCreateInfo,
2393 VkDescriptorPool* pDescriptorPool);
2394
2395VkResult VKAPI vkResetDescriptorPool(
2396 VkDevice device,
2397 VkDescriptorPool descriptorPool);
2398
2399VkResult VKAPI vkAllocDescriptorSets(
2400 VkDevice device,
2401 VkDescriptorPool descriptorPool,
2402 VkDescriptorSetUsage setUsage,
2403 uint32_t count,
2404 const VkDescriptorSetLayout* pSetLayouts,
2405 VkDescriptorSet* pDescriptorSets,
2406 uint32_t* pCount);
2407
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2408void VKAPI vkUpdateDescriptors(
2409 VkDevice device,
2410 VkDescriptorSet descriptorSet,
2411 uint32_t updateCount,
2412 const void** ppUpdateArray);
2413
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2414VkResult VKAPI vkCreateDynamicViewportState(
2415 VkDevice device,
2416 const VkDynamicVpStateCreateInfo* pCreateInfo,
2417 VkDynamicVpState* pState);
2418
2419VkResult VKAPI vkCreateDynamicRasterState(
2420 VkDevice device,
2421 const VkDynamicRsStateCreateInfo* pCreateInfo,
2422 VkDynamicRsState* pState);
2423
2424VkResult VKAPI vkCreateDynamicColorBlendState(
2425 VkDevice device,
2426 const VkDynamicCbStateCreateInfo* pCreateInfo,
2427 VkDynamicCbState* pState);
2428
2429VkResult VKAPI vkCreateDynamicDepthStencilState(
2430 VkDevice device,
2431 const VkDynamicDsStateCreateInfo* pCreateInfo,
2432 VkDynamicDsState* pState);
2433
Jason Ekstrandd5dccc12015-07-06 14:41:41 -0700[diff] [blame]2434VkResult VKAPI vkCreateFramebuffer(
2435 VkDevice device,
2436 const VkFramebufferCreateInfo* pCreateInfo,
2437 VkFramebuffer* pFramebuffer);
2438
2439VkResult VKAPI vkCreateRenderPass(
2440 VkDevice device,
2441 const VkRenderPassCreateInfo* pCreateInfo,
2442 VkRenderPass* pRenderPass);
2443
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2444VkResult VKAPI vkCreateCommandBuffer(
2445 VkDevice device,
2446 const VkCmdBufferCreateInfo* pCreateInfo,
2447 VkCmdBuffer* pCmdBuffer);
2448
2449VkResult VKAPI vkBeginCommandBuffer(
2450 VkCmdBuffer cmdBuffer,
2451 const VkCmdBufferBeginInfo* pBeginInfo);
2452
2453VkResult VKAPI vkEndCommandBuffer(
2454 VkCmdBuffer cmdBuffer);
2455
2456VkResult VKAPI vkResetCommandBuffer(
2457 VkCmdBuffer cmdBuffer);
2458
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2459void VKAPI vkCmdBindPipeline(
2460 VkCmdBuffer cmdBuffer,
2461 VkPipelineBindPoint pipelineBindPoint,
2462 VkPipeline pipeline);
2463
2464void VKAPI vkCmdBindDynamicStateObject(
2465 VkCmdBuffer cmdBuffer,
2466 VkStateBindPoint stateBindPoint,
2467 VkDynamicStateObject dynamicState);
2468
2469void VKAPI vkCmdBindDescriptorSets(
2470 VkCmdBuffer cmdBuffer,
2471 VkPipelineBindPoint pipelineBindPoint,
2472 uint32_t firstSet,
2473 uint32_t setCount,
2474 const VkDescriptorSet* pDescriptorSets,
2475 uint32_t dynamicOffsetCount,
2476 const uint32_t* pDynamicOffsets);
2477
2478void VKAPI vkCmdBindIndexBuffer(
2479 VkCmdBuffer cmdBuffer,
2480 VkBuffer buffer,
2481 VkDeviceSize offset,
2482 VkIndexType indexType);
2483
2484void VKAPI vkCmdBindVertexBuffers(
2485 VkCmdBuffer cmdBuffer,
2486 uint32_t startBinding,
2487 uint32_t bindingCount,
2488 const VkBuffer* pBuffers,
2489 const VkDeviceSize* pOffsets);
2490
2491void VKAPI vkCmdDraw(
2492 VkCmdBuffer cmdBuffer,
2493 uint32_t firstVertex,
2494 uint32_t vertexCount,
2495 uint32_t firstInstance,
2496 uint32_t instanceCount);
2497
2498void VKAPI vkCmdDrawIndexed(
2499 VkCmdBuffer cmdBuffer,
2500 uint32_t firstIndex,
2501 uint32_t indexCount,
2502 int32_t vertexOffset,
2503 uint32_t firstInstance,
2504 uint32_t instanceCount);
2505
2506void VKAPI vkCmdDrawIndirect(
2507 VkCmdBuffer cmdBuffer,
2508 VkBuffer buffer,
2509 VkDeviceSize offset,
2510 uint32_t count,
2511 uint32_t stride);
2512
2513void VKAPI vkCmdDrawIndexedIndirect(
2514 VkCmdBuffer cmdBuffer,
2515 VkBuffer buffer,
2516 VkDeviceSize offset,
2517 uint32_t count,
2518 uint32_t stride);
2519
2520void VKAPI vkCmdDispatch(
2521 VkCmdBuffer cmdBuffer,
2522 uint32_t x,
2523 uint32_t y,
2524 uint32_t z);
2525
2526void VKAPI vkCmdDispatchIndirect(
2527 VkCmdBuffer cmdBuffer,
2528 VkBuffer buffer,
2529 VkDeviceSize offset);
2530
2531void VKAPI vkCmdCopyBuffer(
2532 VkCmdBuffer cmdBuffer,
2533 VkBuffer srcBuffer,
2534 VkBuffer destBuffer,
2535 uint32_t regionCount,
2536 const VkBufferCopy* pRegions);
2537
2538void VKAPI vkCmdCopyImage(
2539 VkCmdBuffer cmdBuffer,
2540 VkImage srcImage,
2541 VkImageLayout srcImageLayout,
2542 VkImage destImage,
2543 VkImageLayout destImageLayout,
2544 uint32_t regionCount,
2545 const VkImageCopy* pRegions);
2546
2547void VKAPI vkCmdBlitImage(
2548 VkCmdBuffer cmdBuffer,
2549 VkImage srcImage,
2550 VkImageLayout srcImageLayout,
2551 VkImage destImage,
2552 VkImageLayout destImageLayout,
2553 uint32_t regionCount,
2554 const VkImageBlit* pRegions);
2555
2556void VKAPI vkCmdCopyBufferToImage(
2557 VkCmdBuffer cmdBuffer,
2558 VkBuffer srcBuffer,
2559 VkImage destImage,
2560 VkImageLayout destImageLayout,
2561 uint32_t regionCount,
2562 const VkBufferImageCopy* pRegions);
2563
2564void VKAPI vkCmdCopyImageToBuffer(
2565 VkCmdBuffer cmdBuffer,
2566 VkImage srcImage,
2567 VkImageLayout srcImageLayout,
2568 VkBuffer destBuffer,
2569 uint32_t regionCount,
2570 const VkBufferImageCopy* pRegions);
2571
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2572void VKAPI vkCmdUpdateBuffer(
2573 VkCmdBuffer cmdBuffer,
2574 VkBuffer destBuffer,
2575 VkDeviceSize destOffset,
2576 VkDeviceSize dataSize,
2577 const uint32_t* pData);
2578
2579void VKAPI vkCmdFillBuffer(
2580 VkCmdBuffer cmdBuffer,
2581 VkBuffer destBuffer,
2582 VkDeviceSize destOffset,
2583 VkDeviceSize fillSize,
2584 uint32_t data);
2585
2586void VKAPI vkCmdClearColorImage(
2587 VkCmdBuffer cmdBuffer,
2588 VkImage image,
2589 VkImageLayout imageLayout,
Jason Ekstrandbeb0e252015-07-01 16:44:10 -0700[diff] [blame]2590 VkClearColor color,
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2591 uint32_t rangeCount,
2592 const VkImageSubresourceRange* pRanges);
2593
2594void VKAPI vkCmdClearDepthStencil(
2595 VkCmdBuffer cmdBuffer,
2596 VkImage image,
2597 VkImageLayout imageLayout,
2598 float depth,
2599 uint32_t stencil,
2600 uint32_t rangeCount,
2601 const VkImageSubresourceRange* pRanges);
2602
2603void VKAPI vkCmdResolveImage(
2604 VkCmdBuffer cmdBuffer,
2605 VkImage srcImage,
2606 VkImageLayout srcImageLayout,
2607 VkImage destImage,
2608 VkImageLayout destImageLayout,
2609 uint32_t regionCount,
2610 const VkImageResolve* pRegions);
2611
2612void VKAPI vkCmdSetEvent(
2613 VkCmdBuffer cmdBuffer,
2614 VkEvent event,
2615 VkPipeEvent pipeEvent);
2616
2617void VKAPI vkCmdResetEvent(
2618 VkCmdBuffer cmdBuffer,
2619 VkEvent event,
2620 VkPipeEvent pipeEvent);
2621
2622void VKAPI vkCmdWaitEvents(
2623 VkCmdBuffer cmdBuffer,
2624 VkWaitEvent waitEvent,
2625 uint32_t eventCount,
2626 const VkEvent* pEvents,
2627 uint32_t memBarrierCount,
2628 const void** ppMemBarriers);
2629
2630void VKAPI vkCmdPipelineBarrier(
2631 VkCmdBuffer cmdBuffer,
2632 VkWaitEvent waitEvent,
2633 uint32_t pipeEventCount,
2634 const VkPipeEvent* pPipeEvents,
2635 uint32_t memBarrierCount,
2636 const void** ppMemBarriers);
2637
2638void VKAPI vkCmdBeginQuery(
2639 VkCmdBuffer cmdBuffer,
2640 VkQueryPool queryPool,
2641 uint32_t slot,
2642 VkQueryControlFlags flags);
2643
2644void VKAPI vkCmdEndQuery(
2645 VkCmdBuffer cmdBuffer,
2646 VkQueryPool queryPool,
2647 uint32_t slot);
2648
2649void VKAPI vkCmdResetQueryPool(
2650 VkCmdBuffer cmdBuffer,
2651 VkQueryPool queryPool,
2652 uint32_t startQuery,
2653 uint32_t queryCount);
2654
2655void VKAPI vkCmdWriteTimestamp(
2656 VkCmdBuffer cmdBuffer,
2657 VkTimestampType timestampType,
2658 VkBuffer destBuffer,
2659 VkDeviceSize destOffset);
2660
2661void VKAPI vkCmdCopyQueryPoolResults(
2662 VkCmdBuffer cmdBuffer,
2663 VkQueryPool queryPool,
2664 uint32_t startQuery,
2665 uint32_t queryCount,
2666 VkBuffer destBuffer,
2667 VkDeviceSize destOffset,
2668 VkDeviceSize destStride,
2669 VkQueryResultFlags flags);
2670
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2671void VKAPI vkCmdBeginRenderPass(
2672 VkCmdBuffer cmdBuffer,
2673 const VkRenderPassBegin* pRenderPassBegin);
2674
2675void VKAPI vkCmdEndRenderPass(
2676 VkCmdBuffer cmdBuffer,
2677 VkRenderPass renderPass);
2678
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]2679#endif
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2680
2681#ifdef __cplusplus
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]2682}
2683#endif
Kristian Høgsberg769785c2015-05-08 22:32:37 -0700[diff] [blame]2684
Jason Ekstrand630b19a2015-07-06 14:30:31 -0700[diff] [blame]2685#endif